minimap2 0.0.0 → 0.2.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2bedd8ea7d7cbcf1b91089982d695964fdd7efd0a3f5357bd2a4385e980eee26
-  data.tar.gz: de3ba9df2cf9651ffa9a4b48d441ab8c8b51e56a9d75586f3d7385507c85c7c1
+  metadata.gz: 4bd850f529cb82950c16581735bdd74f232e0ef3490e5cb5b6f7045faa1fe696
+  data.tar.gz: 40d00cf14886a35f831b593d541cf9e72f8e5cf07d87be31116c215799449f62
 SHA512:
-  metadata.gz: 0cb0a94415322856f59670e4f5ffb1e31c7f1e273438f5fe0b5e5074551d3f0019b349b77295d58a93d4838b1132919cb8f083442ee8b5bc7c5244a34cefbf3c
-  data.tar.gz: 66c02083e183470297d4ee1afd0f26472956bdf77339b642ea7951ca2b9a72ba8747352c3e482a2e9810005c093cb98cb4ea8caa7ba6300c72b1f21f2b56abc7
+  metadata.gz: 669bd6d5a4eb0dc37f12ee4c0f9653bfe76afec70b8d592e291269cb97b90b493b398b8d68ebacb64ba2ce28187a32a32fdb3fb77ef070023ffa27983f479929
+  data.tar.gz: 12c2fd1ace06a7e6a1734cb27f09091851f3fe917714156b27a003a168815dbef83eabc00c56c701bdcd5f982db873346bca375b3e8f05764b7fb797d2d5c898

data/README.md

@@ -1,30 +1,199 @@
-# 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
 
+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
-gem install minimap2
+git clone --recursive https://github.com/kojix2/ruby-minimap2
+cd ruby-minimap2
+bundle install
+bundle exec rake minimap2:build
 ```
 
-## Usage
+Install
 
-```sh
-# TODO
 ```
+bundle exec rake install
+```
+
+Ruby-minimap2 is [tested on Ubuntu and macOS](https://github.com/kojix2/ruby-minimap2/actions). 
+
+## Quick Start
+
+```ruby
+require "minimap2"
+```
+
+Create aligner
+
+```ruby
+aligner = Minimap2::Aligner.new("minimap2/test/MT-human.fa")
+```
+
+Retrieve a subsequence from the index
+
+```ruby
+seq = aligner.seq("MT_human", 100, 200)
+```
+
+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
+
+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                  Read fasta/fastq file.
+  - revcomp                     Reverse complement sequence.
+
+  * 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.)
+      - align                   Maps and returns alignments.
+      - seq                     Retrieve a subsequence from the index.
+
+  * Alignment class
+    * attributes
+      - 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                    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.
+```
+
+This is not all. See the [RubyDoc.info documentation](https://rubydoc.info/gems/minimap2/) for more details.
 
+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
+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.
+then clone.
+
 ```sh
-# TODO
+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 Minimap2 and Mappy.
+
+```sh
+cd ruby-minimap2
+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.
+
+```
+bundle exec rake test
 ```
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/kojix2/ruby-minimap2.
+ruby-minimap2 is a library under development and there are many points to be improved. Please feel free to send us your pull request. 
+
+* [Report bugs](https://github.com/kojix2/ruby-minimap2/issues)
+* Fix bugs and [submit pull requests](https://github.com/kojix2/ruby-minimap2/pulls)
+* Write, clarify, or fix documentation
+* Suggest or add new features
+* Create tools based on ruby-minimap2
+* Update minimap2 in github submodule
 
 ## 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

@@ -1,6 +1,78 @@
-require_relative "minimap/version"
+# frozen_string_literal: true
 
-module Minimap
+# dependencies
+require 'ffi'
+
+# bit fields
+require_relative 'minimap2/ffi_helper'
+
+# modules
+require_relative 'minimap2/aligner'
+require_relative 'minimap2/alignment'
+require_relative 'minimap2/version'
+
+# Minimap2 mapper for long read sequences
+# https://github.com/lh3/minimap2
+# Li, H. (2018). Minimap2: pairwise alignment for nucleotide sequences. Bioinformatics, 34:3094-3100.
+# doi:10.1093/bioinformatics/bty191
+module Minimap2
   class Error < StandardError; end
-  # Your code goes here...
+
+  class << self
+    attr_accessor :ffi_lib
+  end
+
+  lib_name = ::FFI.map_library_name('minimap2')
+  self.ffi_lib = if ENV['MINIMAPDIR']
+                   File.expand_path(lib_name, ENV['MINIMAPDIR'])
+                 else
+                   File.expand_path("../vendor/#{lib_name}", __dir__)
+                 end
+
+  # friendlier error message
+  autoload :FFI, 'minimap2/ffi'
+
+  # methods from mappy
+  class << self
+    # Read fasta/fastq file.
+    # @param [String] file_path
+    # @param [Boolean] read_comment If false or nil, the comment will not be read.
+    # @yield [name, seq, qual, comment]
+    # Note: You can also use a generic library such as BioRuby instead of this method.
+
+    def fastx_read(file_path, read_comment = false)
+      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]
+        end
+      end
+      FFI.mm_fastx_close(ks)
+    end
+
+    # Reverse complement sequence.
+    # @param [String] seq
+    # @return [string] seq
+
+    def revcomp(seq)
+      l = seq.size
+      bseq = ::FFI::MemoryPointer.new(:char, l)
+      bseq.put_bytes(0, seq)
+      FFI.mappy_revcomp(l, bseq)
+    end
+
+    # Set verbosity level.
+    # @param [Integer] level
+
+    def verbose(level = -1)
+      FFI.mm_verbose_level(level)
+    end
+  end
 end

data/lib/minimap2/aligner.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module Minimap2
+  class Aligner
+    attr_reader :idx_opt, :map_opt, :index
+
+    # 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.
+    # @param min_chain_score [Integer] minimum chaing score.
+    # @param min_dp_score
+    # @param bw [Integer] chaining and alignment band width.
+    # @param best_n [Integer] max number of alignments to return.
+    # @param n_threads [Integer] number of indexing threads.
+    # @param fn_idx_out [String] name of file to which the index is written.
+    #   This parameter has no effect if seq is set.
+    # @param max_frag_len [Integer]
+    # @param extra_flags [Integer] additional flags defined in minimap.h.
+    # @param scoring [Array] scoring system.
+    #   It is a tuple/list consisting of 4, 6 or 7 positive integers.
+    #   The first 4 elements specify match scoring, mismatch penalty, gap open and gap extension penalty.
+    #   The 5th and 6th elements, if present, set long-gap open and long-gap extension penalty.
+    #   The 7th sets a mismatch penalty involving ambiguous bases.
+
+    def initialize(
+      fn_idx_in = nil,
+      seq: nil,
+      preset: nil,
+      k: nil,
+      w: nil,
+      min_cnt: nil,
+      min_chain_score: nil,
+      min_dp_score: nil,
+      bw: nil,
+      best_n: nil,
+      n_threads: 3,
+      fn_idx_out: nil,
+      max_frag_len: nil,
+      extra_flags: nil,
+      scoring: nil
+    )
+
+      @idx_opt = FFI::IdxOpt.new
+      @map_opt = FFI::MapOpt.new
+
+      r = FFI.mm_set_opt(preset, idx_opt, map_opt)
+      raise ArgumentError, "Unknown preset name: #{preset}" if r == -1
+
+      # always perform alignment
+      map_opt[:flag] |= 4
+      idx_opt[:batch_size] = 0x7fffffffffffffff
+
+      # override preset options
+      idx_opt[:k] = k if k
+      idx_opt[:w] = w if w
+      map_opt[:min_cnt] = min_cnt if min_cnt
+      map_opt[:min_chain_score] = min_chain_score if min_chain_score
+      map_opt[:min_dp_max] = min_dp_score if min_dp_score
+      map_opt[:bw] = bw if bw
+      map_opt[:best_n] = best_n if best_n
+      map_opt[:max_frag_len] = max_frag_len if max_frag_len
+      map_opt[:flag] |= extra_flags if extra_flags
+      if scoring && scoring.size >= 4
+        map_opt[:a] = scoring[0]
+        map_opt[:b] = scoring[1]
+        map_opt[:q] = scoring[2]
+        map_opt[:e] = scoring[3]
+        map_opt[:q2] = map_opt.q
+        map_opt[:e2] = map_opt.e
+        if scoring.size >= 6
+          map_opt[:q2] = scoring[4]
+          map_opt[:e2] = scoring[5]
+          map_opt[:sc_ambi] = scoring[6] if scoring.size >= 7
+        end
+      end
+
+      if fn_idx_in
+        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
+        raise "Cannot open : #{fn_idx_in}" if reader.null?
+
+        @index = FFI.mm_idx_reader_read(reader, n_threads)
+        FFI.mm_idx_reader_close(reader)
+        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
+        )
+        FFI.mm_mapopt_update(map_opt, index)
+        map_opt[:mid_occ] = 1000 # don't filter high-occ seeds
+      end
+    end
+
+    # Explicitly releases the memory of the index object.
+
+    def free_index
+      FFI.mm_idx_destroy(index) unless index.null?
+    end
+
+    # @param seq [String]
+    # @param seq2 [String]
+    # @param buf [FFI::TBuf]
+    # @param cs [true, false]
+    # @param md [true, false]
+    # @param max_frag_len [Integer]
+    # @param extra_flags [Integer]
+    # @note Name change: map -> align
+    #   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,
+      buf: nil,
+      cs: false,
+      md: false,
+      max_frag_len: nil,
+      extra_flags: nil
+    )
+
+      return if index.null?
+
+      map_opt.max_frag_len = max_frag_len if max_frag_len
+      map_opt.flag |= extra_flags if extra_flags
+
+      buf ||= FFI::TBuf.new
+      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)
+      n_regs = n_regs_ptr.read_int
+
+      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)
+
+          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 = ''
+          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)
+          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
+    end
+
+    # Retrieve a subsequence from the index.
+    # @param name
+    # @param start
+    # @param stop
+
+    def seq(name, start = 0, stop = 0x7fffffff)
+      lp = ::FFI::MemoryPointer.new(:int)
+      s = FFI.mappy_fetch_seq(index, name, start, stop, lp)
+      l = lp.read_int
+      return nil if l.zero?
+
+      s.read_string(l)
+    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
+
+    def n_seq
+      index[: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]
+      end
+    end
+  end
+end

data/lib/minimap2/alignment.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Minimap2
+  # Alignment result.
+  #
+  # @!attribute ctg
+  #   @return [String] name of the reference sequence the query is mapped to.
+  # @!attribute ctg_len
+  #   @return [Integer] total length of the reference sequence.
+  # @!attribute r_st
+  #   @return [Integer] start positions on the reference.
+  # @!attribute r_en
+  #   @return [Integer] end positions on the reference.
+  # @!attribute strand
+  #   @return [Integer] +1 if on the forward strand; -1 if on the reverse strand.
+  # @!attribute trans_strand
+  #   @return [Integer] transcript strand.
+  #     +1 if on the forward strand; -1 if on the reverse strand; 0 if unknown.
+  # @!attribute blen
+  #   @return [Integer] length of the alignment, including both alignment matches and gaps
+  #      but excluding ambiguous bases.
+  # @!attribute mlen
+  #   @return [Integer] length of the matching bases in the alignment,
+  #     excluding ambiguous base matches.
+  # @!attribute nm
+  #   @return [Integer] number of mismatches, gaps and ambiguous poistions in the alignment.
+  # @!attribute primary
+  #   @return [Integer] if the alignment is primary (typically the best and the first to generate)
+  # @!attribute q_st
+  #   @return [Integer] start positions on the query.
+  # @!attribute q_en
+  #   @return [Integer] end positions on the query.
+  # @!attribute mapq
+  #   @return [Integer] mapping quality.
+  # @!attribute cigar
+  #   @return [Array] CIGAR returned as an array of shape (n_cigar,2).
+  #     The two numbers give the length and the operator of each CIGAR operation.
+  # @!attribute read_num
+  #   @return [Integer] read number that the alignment corresponds to;
+  #     1 for the first read and 2 for the second read.
+  # @!attribute cs
+  #   @return [String] the cs tag.
+  # @!attribute md
+  #   @return [String] the MD tag as in the SAM format.
+  #     It is an empty string unless the md argument is applied when calling Aligner#align.
+  # @!attribute cigar_str
+  #   @return [String] CIGAR string.
+
+  class Alignment
+    def self.keys
+      %i[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]
+    end
+
+    attr_reader(*keys)
+
+    def initialize(h, cigar, cs = nil, md = nil)
+      @ctg          = h[:ctg]
+      @ctg_len      = h[:ctg_len]
+      @r_st         = h[:ctg_start]
+      @r_en         = h[:ctg_end]
+      @strand       = h[:strand]
+      @trans_strand = h[:trans_strand]
+      @blen         = h[:blen]
+      @mlen         = h[:mlen]
+      @nm           = h[:NM]
+      @primary      = h[:is_primary]
+      @q_st         = h[:qry_start]
+      @q_en         = h[:qry_end]
+      @mapq         = h[:mapq]
+      @cigar        = cigar
+      @read_num     = h[:seg_id] + 1
+      @cs           = cs
+      @md           = md
+
+      @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?
+                 '+'
+               elsif @strand.negative?
+                 '-'
+               else
+                 '?'
+               end
+      tp = @primary != 0 ? 'tp:A:P' : 'tp:A:S'
+      ts = if @trans_strand.positive?
+             'ts:A:+'
+           elsif @trans_strand.negative?
+             'ts:A:-'
+           else
+             'ts:A:.'
+           end
+      a = [@q_st, @q_en, strand, @ctg, @ctg_len, @r_st, @r_en,
+           @mlen, @blen, @mapq, tp, ts, "cg:Z:#{@cigar_str}"]
+      a << "cs:Z:#{@cs}" if @cs
+      a.join("\t")
+    end
+  end
+end

data/lib/minimap2/ffi.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# bit fields
+require_relative 'ffi_helper'
+
+module Minimap2
+  # Native APIs
+  module FFI
+    extend ::FFI::Library
+    begin
+      ffi_lib Minimap2.ffi_lib
+    rescue LoadError => e
+      raise LoadError, "Could not find #{Minimap2.ffi_lib} \n#{e}"
+    end
+
+    # Continue even if some functions are not found.
+    def self.attach_function(*)
+      super
+    rescue ::FFI::NotFoundError => e
+      warn e.message
+    end
+  end
+end
+
+require_relative 'ffi/constants'
+require_relative 'ffi/functions'
+require_relative 'ffi/mappy'

data/lib/minimap2/ffi/constants.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+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
+    RMQ            = 0x80000000 # LL
+
+    HPC            = 0x1
+    NO_SEQ         = 0x2
+    NO_NAME        = 0x4
+
+    IDX_MAGIC      = "MMI\2"
+
+    MAX_SEG        = 255
+
+    CIGAR_STR      = 'MIDNSHP=XB'
+
+    # emulate 128-bit integers
+    class MM128 < ::FFI::Struct
+      layout \
+        :x, :uint64_t,
+        :y, :uint64_t
+    end
+
+    # emulate 128-bit arrays
+    class MM128V < ::FFI::Struct
+      layout \
+        :n, :size_t,
+        :m, :size_t,
+        :a, MM128.ptr
+    end
+
+    # indexing option
+    class IdxOpt < ::FFI::Struct
+      layout \
+        :k,               :short,
+        :w,               :short,
+        :flag,            :short,
+        :bucket_bits,     :short,
+        :mini_batch_size, :int64_t,
+        :batch_size,      :uint64_t
+    end
+
+    # mapping option
+    class MapOpt < ::FFI::Struct
+      layout \
+        :flag,                 :int64_t, # see MM_F_* macros
+        :seed,                 :int,
+        :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,
+        :max_chain_skip,       :int,
+        :max_chain_iter,       :int,
+        :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
+        :alt_drop,             :float,
+        :a,                    :int,     # matching score
+        :b,                    :int,     # mismatch
+        :q,                    :int,     # gap-open
+        :e,                    :int,     # gap-ext
+        :q2,                   :int,     # gap-open
+        :e2,                   :int,     # gap-ext
+        :sc_ambi,              :int,     # score when one or both bases are "N"
+        :noncan,               :int,     # cost of non-canonical splicing sites
+        :junc_bonus,           :int,
+        :zdrop,                :int,     # break alignment if alignment score drops too fast along the diagonal
+        :zdrop_inv,            :int,
+        :end_bonus,            :int,
+        :min_dp_max,           :int,     # drop an alignment if the score of the max scoring segment is below this threshold
+        :min_ksw_len,          :int,
+        :anchor_ext_len,       :int,
+        :anchor_ext_shift,     :int,
+        :max_clip_ratio,       :float,   # drop an alignment if BOTH ends are clipped above this ratio
+        :pe_ori,               :int,
+        :pe_bonus,             :int,
+        :mid_occ_frac,         :float,   # only used by mm_mapopt_update(); see below
+        :min_mid_occ,          :int32_t,
+        :mid_occ,              :int32_t, # ignore seeds with occurrences above this threshold
+        :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,
+        :split_prefix,         :string
+    end
+
+    # minimap2 index
+    class IdxSeq < ::FFI::Struct
+      layout \
+        :name,   :string,    # name of the db sequence
+        :offset, :uint64_t,  # offset in mm_idx_t::S
+        :len,    :uint32_t,  # length
+        :is_alt, :uint32_t
+    end
+
+    class Idx < ::FFI::Struct
+      layout \
+        :b,     :int32_t,
+        :w,     :int32_t,
+        :k,     :int32_t,
+        :flag,  :int32_t,
+        :n_seq, :uint32_t,   # number of reference sequences
+        :index, :int32_t,
+        :n_alt, :int32_t,
+        :seq,   IdxSeq.ptr,  # sequence name, length and offset
+        :S,     :pointer,    # 4-bit packed sequence
+        :B,     :pointer,    # index (hidden)
+        :I,     :pointer,    # intervals (hidden)
+        :km,    :pointer,
+        :h,     :pointer
+    end
+
+    # index reader
+    class IdxReader < ::FFI::Struct
+      layout \
+        :is_idx,      :int,
+        :n_parts,     :int,
+        :idx_size,    :int64_t,
+        :opt,         IdxOpt,
+        :fp_out,      :pointer, # FILE
+        :seq_or_idx,  :pointer  # FIXME: Union mm_bseq_files or FILE
+    end
+
+    # minimap2 alignment
+    class Extra < ::FFI::BitStruct
+      layout \
+        :capacity,            :uint32,  # the capacity of cigar[]
+        :dp_score,            :int32,   # DP score
+        :dp_max,              :int32,   # score of the max-scoring segment
+        :dp_max2,             :int32,   # score of the best alternate mappings
+        :n_ambi_trans_strand, :uint32,
+        :n_cigar,             :uint32
+
+      bitfields :n_ambi_trans_strand,
+                :n_ambi, 30,      # number of ambiguous bases
+                :trans_strand, 2  # transcript strand: 0 for unknown, 1 for +, 2 for -
+
+      # variable length array
+      def cigar
+        pointer.get_array_of_uint32(size, self[:n_cigar])
+      end
+    end
+
+    class Reg1 < ::FFI::BitStruct
+      layout \
+        :id,     :int32_t, # ID for internal uses (see also parent below)
+        :cnt,    :int32_t, # number of minimizers; if on the reverse strand
+        :rid,    :int32_t, # reference index; if this is an alignment from inversion rescue
+        :score,  :int32_t, # DP alignment score
+        :qs,     :int32_t, # query start
+        :qe,     :int32_t, # query end
+        :rs,     :int32_t, # reference start
+        :re,     :int32_t, # reference end
+        :parent, :int32_t, # parent==id if primary
+        :subsc,  :int32_t, # best alternate mapping score
+        :as,     :int32_t, # offset in the a[] array (for internal uses only)
+        :mlen,   :int32_t, # seeded exact match length
+        :blen,   :int32_t, # seeded alignment block length
+        :n_sub,  :int32_t, # number of suboptimal mappings
+        :score0, :int32_t, # initial chaining score (before chain merging/spliting)
+        :fields, :uint32_t,
+        :hash,   :uint32_t,
+        :div,    :float,
+        :p,      Extra.ptr
+
+      bitfields :fields,
+                :mapq,        8,
+                :split,       2,
+                :rev,         1,
+                :inv,         1,
+                :sam_pri,     1,
+                :proper_frag, 1,
+                :pe_thru,     1,
+                :seg_split,   1,
+                :seg_id,      8,
+                :split_inv,   1,
+                :is_alt,      1,
+                :dummy,       6
+    end
+
+    # memory buffer for thread-local storage during mapping
+    class TBuf < ::FFI::Struct
+      layout \
+        :km,       :pointer,
+        :rep_len,  :int,
+        :frag_gap, :int
+    end
+  end
+end

data/lib/minimap2/ffi/functions.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Minimap2
+  module FFI
+    attach_function \
+      :mm_set_opt_raw, :mm_set_opt,
+      [:pointer, IdxOpt.by_ref, MapOpt.by_ref],
+      :int
+
+    private_class_method :mm_set_opt_raw
+
+    def self.mm_set_opt(preset, io, mo)
+      ptr = if preset
+              ::FFI::MemoryPointer.from_string(preset.to_s)
+            else
+              ::FFI::Pointer.new(:int, 0)
+            end
+      mm_set_opt_raw(ptr, io, mo)
+    end
+
+    attach_function \
+      :mm_idx_reader_open,
+      [:string, IdxOpt.by_ref, :string],
+      IdxReader.by_ref
+
+    attach_function \
+      :mm_idx_reader_read,
+      [IdxReader.by_ref, :int],
+      Idx.by_ref
+
+    attach_function \
+      :mm_idx_reader_close,
+      [IdxReader.by_ref],
+      :void
+
+    attach_function \
+      :mm_idx_destroy,
+      [Idx.by_ref],
+      :void
+
+    attach_function \
+      :mm_mapopt_update,
+      [MapOpt.by_ref, Idx.by_ref],
+      :void
+
+    attach_function \
+      :mm_idx_index_name,
+      [Idx.by_ref],
+      :int
+
+    attach_function \
+      :mm_tbuf_init,
+      [],
+      TBuf.by_ref
+
+    attach_function \
+      :mm_tbuf_destroy,
+      [TBuf.by_ref],
+      :void
+
+    attach_function \
+      :mm_tbuf_get_km,
+      [TBuf.by_ref],
+      :pointer
+
+    attach_function \
+      :mm_gen_cs,
+      [:pointer, :pointer, :pointer, Idx.by_ref, Reg1.by_ref, :string, :int],
+      :int
+
+    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
+  end
+end

data/lib/minimap2/ffi/mappy.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+# https://github.com/lh3/minimap2/blob/master/python/cmappy.h
+
+module Minimap2
+  module FFI
+    class Hit < ::FFI::Struct
+      layout \
+        :ctg,          :string,
+        :ctg_start,    :int32_t,
+        :ctg_end,      :int32_t,
+        :qry_start,    :int32_t,
+        :qry_end,      :int32_t,
+        :blen,         :int32_t,
+        :mlen,         :int32_t,
+        :NM,           :int32_t,
+        :ctg_len,      :int32_t,
+        :mapq,         :uint8_t,
+        :is_primary,   :uint8_t,
+        :strand,       :int8_t,
+        :trans_strand, :int8_t,
+        :seg_id,       :int32_t,
+        :n_cigar32,    :int32_t,
+        :cigar32,      :pointer
+    end
+
+    class KString < ::FFI::Struct
+      layout \
+        :l,            :size_t,
+        :m,            :size_t,
+        :s,            :string
+    end
+
+    class KSeq < ::FFI::Struct
+      layout \
+        :name,           KString,
+        :comment,        KString,
+        :seq,            KString,
+        :qual,           KString,
+        :last_char,      :int,
+        :f,              :pointer # KStream
+    end
+
+    attach_function \
+      :mm_reg2hitpy,
+      [Idx.by_ref, Reg1.by_ref, Hit.by_ref],
+      :void
+
+    attach_function \
+      :mm_free_reg1,
+      [Reg1.by_ref],
+      :void
+
+    attach_function \
+      :mm_fastx_open,
+      [:string],
+      KSeq.by_ref
+
+    attach_function \
+      :mm_fastx_close,
+      [KSeq.by_ref],
+      :void
+
+    attach_function \
+      :mm_verbose_level,
+      [:int],
+      :int
+
+    attach_function \
+      :mm_reset_timer,
+      [:void],
+      :void
+
+    attach_function \
+      :mm_map_aux,
+      [Idx.by_ref, :string, :string, :pointer, TBuf.by_ref, MapOpt.by_ref],
+      :pointer # Reg1
+
+    attach_function \
+      :mappy_revcomp,
+      %i[int pointer],
+      :string
+
+    attach_function \
+      :mappy_fetch_seq,
+      [Idx.by_ref, :string, :int, :int, :pointer],
+      :pointer # Use pointer instead of string to read with a specified length
+
+    attach_function \
+      :mappy_idx_seq,
+      %i[int int int int string int],
+      Idx.by_ref
+
+    attach_function \
+      :kseq_read,
+      [KSeq.by_ref],
+      :int
+  end
+end

data/lib/minimap2/ffi_helper.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module FFI
+  class BitStruct < Struct
+    class << self
+      # def union_layout(*args)
+      #   Class.new(FFI::Union) { layout(*args) }
+      # end
+
+      # def struct_layout(*args)
+      #   Class.new(FFI::Struct) { layout(*args) }
+      # end
+
+      module BitFieldsModule
+        def [](name)
+          bit_fields = self.class.bit_fields_map
+          parent, start, width = bit_fields[name]
+          if parent
+            (super(parent) >> start) & ((1 << width) - 1)
+          else
+            super(name)
+          end
+        end
+      end
+      private_constant :BitFieldsModule
+
+      attr_reader :bit_fields_map
+
+      def bitfields(*args)
+        unless instance_variable_defined?(:@bit_fields)
+          @bit_fields_map = {}
+          prepend BitFieldsModule
+        end
+
+        parent = args.shift
+        labels = []
+        widths = []
+        args.each_slice(2) do |l, w|
+          labels << l
+          widths << w
+        end
+        starts = widths.inject([0]) do |result, w|
+          result << (result.last + w)
+        end
+        labels.zip(starts, widths).each do |l, s, w|
+          @bit_fields_map[l] = [parent, s, w]
+        end
+      end
+    end
+  end
+end

data/lib/minimap2/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Minimap2
+  # Minimap2-2.21 (r1071).
+  VERSION = '0.2.21'
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: minimap2
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.2.21
 platform: ruby
 authors:
 - kojix2
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-31 00:00:00.000000000 Z
+date: 2021-07-06 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty-command
+  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'
 description: minimap2
 email:
 - 2xijok@gmail.com
@@ -75,8 +103,16 @@ extra_rdoc_files: []
 files:
 - LICENSE.txt
 - README.md
-- lib/minimap/version.rb
 - lib/minimap2.rb
+- lib/minimap2/aligner.rb
+- lib/minimap2/alignment.rb
+- lib/minimap2/ffi.rb
+- lib/minimap2/ffi/constants.rb
+- lib/minimap2/ffi/functions.rb
+- 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
@@ -96,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.15
 signing_key: 
 specification_version: 4
 summary: minimap2

data/lib/minimap/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module Minimap
-  VERSION = "0.0.0"
-end