htslib 0.0.10 → 0.2.1

data/lib/hts/bam.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-# Based on hts-python
-# https://github.com/quinlan-lab/hts-python
-
 require_relative "../htslib"
 
 require_relative "hts"
@@ -12,10 +9,11 @@ require_relative "bam/flag"
 require_relative "bam/record"
 
 module HTS
+  # A class for working with SAM, BAM, CRAM files.
   class Bam
     include Enumerable
 
-    attr_reader :file_name, :index_path, :mode, :header
+    attr_reader :file_name, :index_name, :mode, :header
 
     def self.open(*args, **kw)
       file = new(*args, **kw) # do not yield
@@ -38,9 +36,10 @@ module HTS
 
       # NOTE: Do not check for the existence of local files, since file_names may be remote URIs.
 
-      @file_name = file_name
-      @mode      = mode
-      @hts_file  = LibHTS.hts_open(@file_name, mode)
+      @file_name  = file_name
+      @index_name = index
+      @mode       = mode
+      @hts_file   = LibHTS.hts_open(@file_name, mode)
 
       raise Errno::ENOENT, "Failed to open #{@file_name}" if @hts_file.null?
 
@@ -49,33 +48,31 @@ module HTS
         raise "Failed to load fasta index: #{fai}" if r < 0
       end
 
-      if threads&.> 0
-        r = LibHTS.hts_set_threads(@hts_file, threads)
-        raise "Failed to set number of threads: #{threads}" if r < 0
-      end
+      set_threads(threads) if threads
 
       return if @mode[0] == "w"
 
       @header = Bam::Header.new(@hts_file)
-
       create_index(index) if create_index
-
       @idx = load_index(index)
-
       @start_position = tell
+      super # do nothing
     end
 
     def create_index(index_name = nil)
+      check_closed
+
+      warn "Create index for #{@file_name} to #{index_name}"
       if index
-        warn "Create index for #{@file_name} to #{index_name}"
         LibHTS.sam_index_build2(@file_name, index_name, -1)
       else
-        warn "Create index for #{@file_name} to #{index_name}"
         LibHTS.sam_index_build(@file_name, -1)
       end
     end
 
     def load_index(index_name = nil)
+      check_closed
+
       if index_name
         LibHTS.sam_index_load2(@hts_file, @file_name, index_name)
       else
@@ -84,6 +81,8 @@ module HTS
     end
 
     def index_loaded?
+      check_closed
+
       !@idx.null?
     end
 
@@ -91,29 +90,34 @@ module HTS
     def close
       LibHTS.hts_idx_destroy(@idx) if @idx&.null?
       @idx = nil
-      LibHTS.hts_close(@hts_file)
-      @hts_file = nil
-    end
-
-    def closed?
-      @hts_file.nil? || @hts_file.null?
+      super
     end
 
     def write_header(header)
+      check_closed
+
       @header = header.dup
       LibHTS.hts_set_fai_filename(@hts_file, @file_name)
       LibHTS.sam_hdr_write(@hts_file, header)
     end
 
     def write(aln)
+      check_closed
+
       aln_dup = aln.dup
       LibHTS.sam_write1(@hts_file, header, aln_dup) > 0 || raise
     end
 
-    # Iterate over each record.
-    # Generate a new Record object each time.
-    # Slower than each.
-    def each_copy
+    def each(copy: false, &block)
+      if copy
+        each_record_copy(&block)
+      else
+        each_record_reuse(&block)
+      end
+    end
+
+    private def each_record_copy
+      check_closed
       return to_enum(__method__) unless block_given?
 
       while LibHTS.sam_read1(@hts_file, header, bam1 = LibHTS.bam_init1) != -1
@@ -123,13 +127,10 @@ module HTS
       self
     end
 
-    # Iterate over each record.
-    # Record object is reused.
-    # Faster than each_copy.
-    def each
+    private def each_record_reuse
+      check_closed
       # Each does not always start at the beginning of the file.
       # This is the common behavior of IO objects in Ruby.
-      # This may change in the future.
       return to_enum(__method__) unless block_given?
 
       bam1 = LibHTS.bam_init1
@@ -138,22 +139,109 @@ module HTS
       self
     end
 
-    # query [WIP]
-    def query(region)
+    def query(region, copy: false, &block)
+      if copy
+        query_copy(region, &block)
+      else
+        query_reuse(region, &block)
+      end
+    end
+
+    private def query_copy(region)
+      check_closed
       raise "Index file is required to call the query method." unless index_loaded?
+      return to_enum(__method__, region) unless block_given?
 
       qiter = LibHTS.sam_itr_querys(@idx, header, region)
+
       begin
-        bam1 = LibHTS.bam_init1
-        slen = LibHTS.sam_itr_next(@hts_file, qiter, bam1)
-        while slen > 0
-          yield Record.new(bam1, header)
+        loop do
           bam1 = LibHTS.bam_init1
           slen = LibHTS.sam_itr_next(@hts_file, qiter, bam1)
+          break if slen == -1
+          raise if slen < -1
+
+          yield Record.new(bam1, header)
         end
       ensure
         LibHTS.hts_itr_destroy(qiter)
       end
+      self
+    end
+
+    private def query_reuse(region)
+      check_closed
+      raise "Index file is required to call the query method." unless index_loaded?
+      return to_enum(__method__, region) unless block_given?
+
+      qiter = LibHTS.sam_itr_querys(@idx, header, region)
+
+      bam1 = LibHTS.bam_init1
+      record = Record.new(bam1, header)
+      begin
+        yield record while LibHTS.sam_itr_next(@hts_file, qiter, bam1) > 0
+      ensure
+        LibHTS.hts_itr_destroy(qiter)
+      end
+      self
+    end
+
+    # @!macro [attach] define_getter
+    #   @method $1
+    #   Get $1 array
+    #   @return [Array] the $1 array
+    define_getter :qname
+    define_getter :flag
+    define_getter :chrom
+    define_getter :pos
+    define_getter :mapq
+    define_getter :cigar
+    define_getter :mate_chrom
+    define_getter :mate_pos
+    define_getter :insert_size
+    define_getter :seq
+    define_getter :qual
+
+    alias isize insert_size
+    alias mpos mate_pos
+
+    def aux(tag)
+      warn "experimental"
+      check_closed
+      position = tell
+      ary = map { |r| r.aux(tag) }
+      seek(position)
+      ary
+    end
+
+    # @!macro [attach] define_iterator
+    #   @method each_$1
+    #   Get $1 iterator
+    define_iterator :qname
+    define_iterator :flag
+    define_iterator :chrom
+    define_iterator :pos
+    define_iterator :mapq
+    define_iterator :cigar
+    define_iterator :mate_chrom
+    define_iterator :mate_pos
+    define_iterator :insert_size
+    define_iterator :seq
+    define_iterator :qual
+
+    alias each_isize each_insert_size
+    alias each_mpos each_mate_pos
+
+    def each_aux(tag)
+      warn "experimental"
+      check_closed
+      return to_enum(__method__, tag) unless block_given?
+
+      each do |record|
+        yield record.aux(tag)
+      end
+
+      self
     end
   end
 end

data/lib/hts/bcf/format.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-# https://github.com/brentp/hts-nim/blob/master/src/hts/vcf.nim
-# This is a port from Nim.
-# TODO: Make it more like Ruby.
-
 module HTS
   class Bcf < Hts
     class Format
@@ -32,20 +28,32 @@ module HTS
         get(key, :string)
       end
 
+      def [](key)
+        get(key)
+      end
+
       def get(key, type = nil)
         n = FFI::MemoryPointer.new(:int)
         p1 = @p1
         h = @record.header.struct
         r = @record.struct
 
-        format_values = proc do |type|
-          ret = LibHTS.bcf_get_format_values(h, r, key, p1, n, type)
+        format_values = proc do |typ|
+          ret = LibHTS.bcf_get_format_values(h, r, key, p1, n, typ)
           return nil if ret < 0 # return from method.
 
           p1.read_pointer
         end
 
-        case type.to_sym
+        # The GT FORMAT field is special in that it is marked as a string in the header,
+        # but it is actually encoded as an integer.
+        if key == "GT"
+          type = :int
+        elsif type.nil?
+          type = ht_type_to_sym(get_fmt_type(key))
+        end
+
+        case type&.to_sym
         when :int, :int32
           format_values.call(LibHTS::BCF_HT_INT)
                        .read_array_of_int32(n.read_int)
@@ -53,22 +61,85 @@ module HTS
           format_values.call(LibHTS::BCF_HT_REAL)
                        .read_array_of_float(n.read_int)
         when :flag
-          raise NotImplementedError, "Flag type not implemented yet."
+          raise NotImplementedError, "Flag type not implemented yet. " \
+          "Please file an issue on GitHub."
           # format_values.call(LibHTS::BCF_HT_FLAG)
           #              .read_int == 1
         when :string, :str
-          raise NotImplementedError, "String type not implemented yet."
+          raise NotImplementedError, "String type not implemented yet. " \
+          "Please file an issue on GitHub."
           # format_values.call(LibHTS::BCF_HT_STR)
           #              .read_string
         end
       end
 
-      def set; end
+      def fields
+        ids.map do |id|
+          name = LibHTS.bcf_hdr_int2id(@record.header.struct, LibHTS::BCF_DT_ID, id)
+          num  = LibHTS.bcf_hdr_id2number(@record.header.struct, LibHTS::BCF_HL_FMT, id)
+          type = LibHTS.bcf_hdr_id2type(@record.header.struct, LibHTS::BCF_HL_FMT, id)
+          {
+            name:,
+            n: num,
+            type: ht_type_to_sym(type),
+            id:
+          }
+        end
+      end
 
-      # def fields # iterator
-      # end
+      def length
+        @record.struct[:n_fmt]
+      end
+
+      def size
+        length
+      end
+
+      def to_h
+        ret = {}
+        ids.each do |id|
+          name = LibHTS.bcf_hdr_int2id(@record.header.struct, LibHTS::BCF_DT_ID, id)
+          ret[name] = get(name)
+        end
+        ret
+      end
 
-      def genotypes; end
+      # def genotypes; end
+
+      private
+
+      def fmt_ptr
+        @record.struct[:d][:fmt].to_ptr
+      end
+
+      def ids
+        fmt_ptr.read_array_of_struct(LibHTS::BcfFmt, length).map do |fmt|
+          fmt[:id]
+        end
+      end
+
+      def get_fmt_type(qname)
+        @record.struct[:n_fmt].times do |i|
+          fmt = LibHTS::BcfFmt.new(@record.struct[:d][:fmt] + i * LibHTS::BcfFmt.size)
+          id = fmt[:id]
+          name = LibHTS.bcf_hdr_int2id(@record.header.struct, LibHTS::BCF_DT_ID, id)
+          if name == qname
+            type = LibHTS.bcf_hdr_id2type(@record.header.struct, LibHTS::BCF_HL_FMT, id)
+            return type
+          end
+        end
+        nil
+      end
+
+      def ht_type_to_sym(t)
+        case t
+        when LibHTS::BCF_HT_FLAG then :flag
+        when LibHTS::BCF_HT_INT then :int
+        when LibHTS::BCF_HT_REAL then :float
+        when LibHTS::BCF_HT_STR then :string
+        when LibHTS::BCF_HT_LONG then :float
+        end
+      end
     end
   end
 end

data/lib/hts/bcf/header.rb

@@ -2,6 +2,7 @@
 
 module HTS
   class Bcf < Hts
+    # A class for working with VCF records.
     class Header
       def initialize(hts_file)
         @bcf_hdr = LibHTS.bcf_hdr_read(hts_file)

data/lib/hts/bcf/header_record.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module HTS
+  class Bcf < Hts
+    class HeaderRecord
+      def initialize
+        @bcf_hrec
+      end
+    end
+  end
+end

data/lib/hts/bcf/info.rb

@@ -2,6 +2,7 @@
 
 module HTS
   class Bcf < Hts
+    # Info field
     class Info
       def initialize(record)
         @record = record
@@ -28,6 +29,10 @@ module HTS
         get(key, :flag)
       end
 
+      def [](key)
+        get(key)
+      end
+
       # @note Specify the type. If you don't specify a type, it will still work, but it will be slower.
       def get(key, type = nil)
         n = FFI::MemoryPointer.new(:int)
@@ -35,14 +40,14 @@ module HTS
         h = @record.header.struct
         r = @record.struct
 
-        info_values = proc do |type|
-          ret = LibHTS.bcf_get_info_values(h, r, key, p1, n, type)
+        info_values = proc do |typ|
+          ret = LibHTS.bcf_get_info_values(h, r, key, p1, n, typ)
           return nil if ret < 0 # return from method.
 
           p1.read_pointer
         end
 
-        type ||= info_type_to_string(get_info_type(key))
+        type ||= ht_type_to_sym(get_info_type(key))
 
         case type&.to_sym
         when :int, :int32
@@ -67,47 +72,68 @@ module HTS
 
       # FIXME: naming? room for improvement.
       def fields
-        n_info = @record.struct[:n_info]
-        Array.new(n_info) do |i|
-          fld = LibHTS::BcfInfo.new(
-            @record.struct[:d][:info] +
-            i * LibHTS::BcfInfo.size
-          )
+        keys.map do |key|
+          name = LibHTS.bcf_hdr_int2id(@record.header.struct, LibHTS::BCF_DT_ID, key)
+          num  = LibHTS.bcf_hdr_id2number(@record.header.struct, LibHTS::BCF_HL_INFO, key)
+          type = LibHTS.bcf_hdr_id2type(@record.header.struct, LibHTS::BCF_HL_INFO, key)
           {
-            name: LibHTS.bcf_hdr_int2id(
-              @record.header.struct, LibHTS::BCF_DT_ID, fld[:key]
-            ),
-            n: LibHTS.bcf_hdr_id2number(
-              @record.header.struct, LibHTS::BCF_HL_INFO, fld[:key]
-            ),
-            vtype: fld[:type], i: fld[:key]
+            name:,
+            n: num,
+            type: ht_type_to_sym(type),
+            key:
           }
         end
       end
 
+      def length
+        @record.struct[:n_info]
+      end
+
+      def size
+        length
+      end
+
+      def to_h
+        ret = {}
+        keys.each do |key|
+          name = LibHTS.bcf_hdr_int2id(@record.header.struct, LibHTS::BCF_DT_ID, key)
+          ret[name] = get(name)
+        end
+        ret
+      end
+
       private
 
+      def info_ptr
+        @record.struct[:d][:info].to_ptr
+      end
+
+      def keys
+        info_ptr.read_array_of_struct(LibHTS::BcfInfo, length).map do |info|
+          info[:key]
+        end
+      end
+
       def get_info_type(key)
         @record.struct[:n_info].times do |i|
-          fld = LibHTS::BcfInfo.new(
-            @record.struct[:d][:info] +
-            i * LibHTS::BcfInfo.size
-          )
-          id = LibHTS.bcf_hdr_int2id(
-            @record.header.struct, LibHTS::BCF_DT_ID, fld[:key]
-          )
-          return fld[:type] if id == key
+          info = LibHTS::BcfInfo.new(@record.struct[:d][:info] + i * LibHTS::BcfInfo.size)
+          k = info[:key]
+          id = LibHTS.bcf_hdr_int2id(@record.header.struct, LibHTS::BCF_DT_ID, k)
+          if id == key
+            type = LibHTS.bcf_hdr_id2type(@record.header.struct, LibHTS::BCF_HL_INFO, k)
+            return type
+          end
         end
+        nil
       end
 
-      def info_type_to_string(t)
+      def ht_type_to_sym(t)
         case t
-        when 0 then :flag
-        when 1, 2, 3, 4 then :int
-        when 5 then :float
-        when 7 then :string
-        else
-          raise "Unknown info type: #{t}"
+        when LibHTS::BCF_HT_FLAG then :flag
+        when LibHTS::BCF_HT_INT then :int
+        when LibHTS::BCF_HT_REAL then :float
+        when LibHTS::BCF_HT_STR then :string
+        when LibHTS::BCF_HT_LONG then :float
         end
       end
     end

data/lib/hts/bcf/record.rb

@@ -2,6 +2,7 @@
 
 module HTS
   class Bcf < Hts
+    # A class for working with VCF records.
     class Record
       def initialize(bcf_t, header)
         @bcf1 = bcf_t
@@ -18,57 +19,46 @@ module HTS
         @bcf1.to_ptr
       end
 
-      # def inspect; end
-
-      def formats; end
+      # Get the reference id of the record.
+      def rid
+        @bcf1[:rid]
+      end
 
-      def genotypes; end
+      def rid=(rid)
+        @bcf1[:rid] = rid
+      end
 
+      # Get the chromosome of variant.
       def chrom
-        rid = @bcf1[:rid]
-
         LibHTS.bcf_hdr_id2name(@header.struct, rid)
       end
 
+      # Return 0-based position.
       def pos
-        @bcf1[:pos] + 1 # FIXME
+        @bcf1[:pos]
       end
 
-      def start
-        @bcf1[:pos]
+      def pos=(pos)
+        @bcf1[:pos] = pos
       end
 
-      def stop
-        @bcf1[:pos] + @bcf1[:rlen]
+      # Return the 0-based, exclusive end position
+      def endpos
+        pos + @bcf1[:rlen]
       end
 
+      # Return the value of the ID column.
       def id
         LibHTS.bcf_unpack(@bcf1, LibHTS::BCF_UN_INFO)
         @bcf1[:d][:id]
       end
 
-      def filter
-        LibHTS.bcf_unpack(@bcf1, LibHTS::BCF_UN_FLT)
-        d = @bcf1[:d]
-        n_flt = d[:n_flt]
-
-        case n_flt
-        when 0
-          "PASS"
-        when 1
-          i = d[:flt].read_int
-          LibHTS.bcf_hdr_int2id(@header.struct, LibHTS::BCF_DT_ID, i)
-        when 2
-          d[:flt].get_array_of_int(0, n_flt).map do |i|
-            LibHTS.bcf_hdr_int2id(@header.struct, LibHTS::BCF_DT_ID, i)
-          end
-        else
-          raise "Unexpected number of filters. n_flt: #{n_flt}"
-        end
+      def id=(id)
+        LibHTS.bcf_update_id(@header, @bcf1, id)
       end
 
-      def qual
-        @bcf1[:qual]
+      def clear_id
+        LibHTS.bcf_update_id(@header, @bcf1, ".")
       end
 
       def ref
@@ -90,14 +80,52 @@ module HTS
         ).map(&:read_string)
       end
 
-      def info
+      # Get variant quality.
+      def qual
+        @bcf1[:qual]
+      end
+
+      def qual=(qual)
+        @bcf1[:qual] = qual
+      end
+
+      def filter
+        LibHTS.bcf_unpack(@bcf1, LibHTS::BCF_UN_FLT)
+        d = @bcf1[:d]
+        n_flt = d[:n_flt]
+
+        case n_flt
+        when 0
+          "PASS"
+        when 1
+          id = d[:flt].read_int
+          LibHTS.bcf_hdr_int2id(@header.struct, LibHTS::BCF_DT_ID, id)
+        when 2..nil
+          d[:flt].get_array_of_int(0, n_flt).map do |i|
+            LibHTS.bcf_hdr_int2id(@header.struct, LibHTS::BCF_DT_ID, i)
+          end
+        else
+          raise "Unexpected number of filters. n_flt: #{n_flt}"
+        end
+      end
+
+      def info(key = nil)
         LibHTS.bcf_unpack(@bcf1, LibHTS::BCF_UN_SHR)
-        Info.new(self)
+        info = Info.new(self)
+        if key
+          info.get(key)
+        else
+          info
+        end
       end
 
-      def format
+      def format(key = nil)
         LibHTS.bcf_unpack(@bcf1, LibHTS::BCF_UN_FMT)
-        Format.new(self)
+        if key
+          Format.new(self).get(key)
+        else
+          Format.new(self)
+        end
       end
 
       def to_s