minimap2 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2bedd8ea7d7cbcf1b91089982d695964fdd7efd0a3f5357bd2a4385e980eee26
-  data.tar.gz: de3ba9df2cf9651ffa9a4b48d441ab8c8b51e56a9d75586f3d7385507c85c7c1
+  metadata.gz: ad687f9f6addf8de0a913d8b3b230539a42f76ce32f77b24576dda10118e3a07
+  data.tar.gz: 853c9994378f2441ad9dbaff0966a97812a3f7708a5b6516391d150f9c70b558
 SHA512:
-  metadata.gz: 0cb0a94415322856f59670e4f5ffb1e31c7f1e273438f5fe0b5e5074551d3f0019b349b77295d58a93d4838b1132919cb8f083442ee8b5bc7c5244a34cefbf3c
-  data.tar.gz: 66c02083e183470297d4ee1afd0f26472956bdf77339b642ea7951ca2b9a72ba8747352c3e482a2e9810005c093cb98cb4ea8caa7ba6300c72b1f21f2b56abc7
+  metadata.gz: 916210eb2b7ab42f1d81cc9873f6bfa5ca2c9b1084ba63c9dc62f6301c54940115fc36e5b2fc63afbec33a60a18fb632bb8ae3e533009a4b47de619d7a026321
+  data.tar.gz: 82435ffd47931e66ab1b99c6d85b2d8413d6cf9fb3152f984857b708e988f09b96a4380ae37d76f3f90c5a10a5300c7b891adc0d161dff4414d6aa2d277b1fc7

data/README.md

@@ -1,28 +1,75 @@
 # Minimap2
 
+[![CI](https://github.com/kojix2/ruby-minimap2/workflows/CI/badge.svg)](https://github.com/kojix2/ruby-minimap2/actions)
+
 :dna: [minimap2](https://github.com/lh3/minimap2) - the long-read mapper - for [Ruby](https://github.com/ruby/ruby)
 
 ## Installation
 
+You need to install it 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. 
+
 ```sh
-gem install minimap2
+git clone --recurse-submodules https://github.com/kojix2/ruby-minimap2
+cd ruby-minimap2
+bundle install
+bundle exec rake minimap2:build
+bundle exec rake install
 ```
 
-## Usage
+You can run tests to see if the installation was successful. 
 
-```sh
-# TODO
 ```
+bundle exec rake test
+```
+
+## Quick Start
+
+```ruby
+require "minimap2"
+
+# load or build index
+aligner = Minimap2::Aligner.new("minimap2/test/MT-human.fa")
+
+# retrieve a subsequence from the index
+seq = aligner.seq("MT_human", 100, 200)
+
+# mapping
+aligner.align(seq) do |h|
+  pp h.to_h
+end
+```
+
+## APIs
 
+See
+* [Mappy: Minimap2 Python Binding](https://github.com/lh3/minimap2/tree/master/python)
+
+```markdown
+* Minimap2 module
+  * Aligner class
+  * Alignment class
+```
 
 ## Development
 
 ```sh
-# TODO
+git clone --recurse-submodules https://github.com/kojix2/ruby-minimap2
+# git clone https://github.com/kojix2/ruby-minimap2
+# cd ruby-minimap2
+# git submodule update -i
+cd ruby-minimap2
+bundle install
+bundle exec rake minimap2:build
+bundle exec rake test
 ```
 
 ## Contributing
 
+ruby-minimap2 is a library under development and there are many points to be improved. 
+If you improve the source code, please feel free to send us your pull request. 
+Typo corrections are also welcome. 
+
 Bug reports and pull requests are welcome on GitHub at https://github.com/kojix2/ruby-minimap2.
 
 ## License

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,180 @@
+# frozen_string_literal: true
+
+module Minimap2
+  class Aligner
+    attr_reader :index_options, :map_options, :index
+
+    def initialize(
+      fn_idx_in, # FIXME
+      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,
+      seq: nil,
+      scoring: nil
+    )
+
+      @index_options = FFI::IdxOpt.new
+      @map_options = FFI::MapOpt.new
+
+      if preset
+        FFI.mm_set_opt(preset, index_options, map_options)
+      else
+        # set the default options
+        FFI.mm_set_opt(0, index_options, map_options)
+      end
+
+      # always perform alignment
+      map_options[:flag] |= 4
+      index_options[:batch_size] = 0x7fffffffffffffff
+
+      # override preset options
+      index_options[:k] = k if k
+      index_options[:w] = w if w
+      map_options[:min_cnt] = min_cnt if min_cnt
+      map_options[:min_chain_score] = min_chain_score if min_chain_score
+      map_options[:min_dp_max] = min_dp_score if min_dp_score
+      map_options[:bw] = bw if bw
+      map_options[:best_n] = best_n if best_n
+      map_options[:max_frag_len] = max_frag_len if max_frag_len
+      map_options[:flag] |= extra_flags if extra_flags
+      if scoring && scoring.size >= 4
+        map_options[:a] = scoring[0]
+        map_options[:b] = scoring[1]
+        map_options[:q] = scoring[2]
+        map_options[:e] = scoring[3]
+        map_options[:q2] = map_options.q
+        map_options[:e2] = map_options.e
+        if scoring.size >= 6
+          map_options[:q2] = scoring[4]
+          map_options[:e2] = scoring[5]
+          map_options[:sc_ambi] = scoring[6] if scoring.size >= 7
+        end
+      end
+
+      if seq
+        @index = FFI.mappy_idx_seq(
+          index_options.w, index_options.k, index_options & 1,
+          index_options.bucket_bits, seq, seq.size
+        )
+        FFI.mm_mapopt_update(map_options, index)
+        map_options.mid_occ = 1000 # don't filter high-occ seeds
+      else
+        reader = FFI.mm_idx_reader_open(fn_idx_in, index_options, 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_options, index)
+        FFI.mm_idx_index_name(index)
+      end
+    end
+
+    # FIXME: naming
+    def destroy
+      FFI.mm_idx_destroy(index) unless index.null?
+    end
+
+    # 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.
+    def align(
+      seq, seq2 = nil,
+      buf: nil,
+      cs: false,
+      md: false,
+      max_frag_len: nil,
+      extra_flags: nil
+    )
+
+      return if index.null?
+
+      map_options.max_frag_len = max_frag_len if max_frag_len
+      map_options.flag |= extra_flags if extra_flags
+
+      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_options)
+      n_regs = n_regs_ptr.read_int
+
+      regs = Array.new(n_regs) { |i| FFI::Reg1.new(ptr + i * FFI::Reg1.size) }
+
+      hit = FFI::Hit.new
+      cs_str     = ::FFI::MemoryPointer.new(::FFI::MemoryPointer.new(:string))
+      m_cs_str   = ::FFI::MemoryPointer.new :int
+      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] }
+
+          _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
+
+          yield 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
+    end
+
+    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
+
+    def k
+      index[:k]
+    end
+
+    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,65 @@
+# frozen_string_literal: true
+
+module Minimap2
+  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
+
+    # Read only
+    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 + "MIDNSH"[x[1]] }.join
+    end
+
+    def primary?
+      @primary == 1
+    end
+
+    def to_h
+      self.class.keys.map { |k| [k, __send__(k)] }.to_h
+    end
+
+    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,227 @@
+# 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
+
+    HPC            = 0x1
+    NO_SEQ         = 0x2
+    NO_NAME        = 0x4
+
+    IDX_MAGIC      = "MMI\2"
+
+    MAX_SEG        = 255
+
+    # 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
+        :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,
+        :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
+        :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)
+      if preset == 0
+        ptr = ::FFI::Pointer.new(:int, 0)
+      else
+        ptr = ::FFI::MemoryPointer.from_string(preset.to_s)
+      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 # FIXME: 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 pointer 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,5 @@
+# frozen_string_literal: true
+
+module Minimap2
+  VERSION = "0.0.1"
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: minimap2
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors:
 - kojix2
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-31 00:00:00.000000000 Z
+date: 2021-03-04 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.3
 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