htslib 0.0.6 → 0.1.0

data/lib/hts/bam.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-# Based on hts-python
-# https://github.com/quinlan-lab/hts-python
+require_relative "../htslib"
 
+require_relative "hts"
 require_relative "bam/header"
 require_relative "bam/cigar"
 require_relative "bam/flag"
@@ -12,99 +12,143 @@ module HTS
   class Bam
     include Enumerable
 
-    attr_reader :file_path, :mode, :header
-    # HtfFile is FFI::BitStruct
-    attr_reader :htf_file
+    attr_reader :file_name, :index_name, :mode, :header
 
-    class << self
-      alias open new
-    end
+    def self.open(*args, **kw)
+      file = new(*args, **kw) # do not yield
+      return file unless block_given?
 
-    def initialize(file_path, mode = "r", create_index: nil)
-      file_path = File.expand_path(file_path)
+      begin
+        yield file
+      ensure
+        file.close
+      end
+      file
+    end
 
-      unless File.exist?(file_path)
-        message = "No such SAM/BAM file - #{file_path}"
+    def initialize(file_name, mode = "r", index: nil, fai: nil, threads: nil,
+                   create_index: false)
+      if block_given?
+        message = "HTS::Bam.new() dose not take block; Please use HTS::Bam.open() instead"
         raise message
       end
 
-      @file_path = file_path
-      @mode      = mode
-      @htf_file  = LibHTS.hts_open(file_path, mode)
-      @header    = Bam::Header.new(LibHTS.sam_hdr_read(htf_file))
-
-      # read
-      if mode[0] == "r"
-        # load index
-        @idx = LibHTS.sam_index_load(htf_file, file_path)
-        # create index
-        if create_index || (@idx.null? && create_index.nil?)
-          warn "Create index for #{file_path}"
-          LibHTS.sam_index_build(file_path, -1)
-          @idx = LibHTS.sam_index_load(htf_file, file_path)
-        end
-      else
-        # FIXME: implement
-        raise "not implemented yet."
+      # NOTE: Do not check for the existence of local files, since file_names may be remote URIs.
+
+      @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?
+
+      if fai
+        r = LibHTS.hts_set_fai_filename(@hts_file, fai)
+        raise "Failed to load fasta index: #{fai}" if r < 0
       end
 
-      # IO like API
-      if block_given?
-        begin
-          yield self
-        ensure
-          close
-        end
+      if threads&.> 0
+        r = LibHTS.hts_set_threads(@hts_file, threads)
+        raise "Failed to set number of threads: #{threads}" if r < 0
       end
-    end
 
-    def struct
-      htf_file
+      return if @mode[0] == "w"
+
+      @header = Bam::Header.new(@hts_file)
+
+      create_index(index) if create_index
+
+      @idx = load_index(index)
+
+      @start_position = tell
     end
 
-    def to_ptr
-      htf_file.to_ptr
+    def create_index(index_name = nil)
+      warn "Create index for #{@file_name} to #{index_name}"
+      if index
+        LibHTS.sam_index_build2(@file_name, index_name, -1)
+      else
+        LibHTS.sam_index_build(@file_name, -1)
+      end
     end
 
-    def write(alns)
-      alns.each do
-        LibHTS.sam_write1(htf_file, header, alns.b) > 0 || raise
+    def load_index(index_name = nil)
+      if index_name
+        LibHTS.sam_index_load2(@hts_file, @file_name, index_name)
+      else
+        LibHTS.sam_index_load3(@hts_file, @file_name, nil, 2) # should be 3 ? (copy remote file to local?)
       end
     end
 
+    def index_loaded?
+      !@idx.null?
+    end
+
     # Close the current file.
     def close
-      LibHTS.hts_close(htf_file)
+      LibHTS.hts_idx_destroy(@idx) if @idx&.null?
+      @idx = nil
+      super
+    end
+
+    def write_header(header)
+      raise IOError, "closed stream" if closed?
+
+      @header = header.dup
+      LibHTS.hts_set_fai_filename(@hts_file, @file_name)
+      LibHTS.sam_hdr_write(@hts_file, header)
     end
 
-    # Flush the current file.
-    def flush
-      # LibHTS.bgzf_flush(@htf_file.fp.bgzf)
+    def write(aln)
+      raise IOError, "closed stream" if 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
+      raise IOError, "closed stream" if closed?
+      return to_enum(__method__) unless block_given?
+
+      while LibHTS.sam_read1(@hts_file, header, bam1 = LibHTS.bam_init1) != -1
+        record = Record.new(bam1, header)
+        yield record
+      end
+      self
+    end
+
+    # Iterate over each record.
+    # Record object is reused.
+    # Faster than each_copy.
     def each
+      raise IOError, "closed stream" if 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?
 
-      while LibHTS.sam_read1(htf_file, header, bam1 = LibHTS.bam_init1) > 0
-        record = Record.new(bam1, header)
-        yield record
-      end
+      bam1 = LibHTS.bam_init1
+      record = Record.new(bam1, header)
+      yield record while LibHTS.sam_read1(@hts_file, header, bam1) != -1
       self
     end
 
     # query [WIP]
     def query(region)
+      raise IOError, "closed stream" if closed?
+      raise "Index file is required to call the query method." unless index_loaded?
+
       qiter = LibHTS.sam_itr_querys(@idx, header, region)
       begin
         bam1 = LibHTS.bam_init1
-        slen = LibHTS.sam_itr_next(htf_file, qiter, bam1)
+        slen = LibHTS.sam_itr_next(@hts_file, qiter, bam1)
         while slen > 0
           yield Record.new(bam1, header)
           bam1 = LibHTS.bam_init1
-          slen = LibHTS.sam_itr_next(htf_file, qiter, bam1)
+          slen = LibHTS.sam_itr_next(@hts_file, qiter, bam1)
         end
       ensure
         LibHTS.hts_itr_destroy(qiter)

data/lib/hts/bcf/format.rb

@@ -1,21 +1,41 @@
 # 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
+  class Bcf < Hts
     class Format
       def initialize(record)
         @record = record
         @p1 = FFI::MemoryPointer.new(:pointer) # FIXME: naming
       end
 
+      # For compatibility with htslib.cr.
+      def get_int(key)
+        get(key, :int)
+      end
+
+      # For compatibility with htslib.cr.
+      def get_float(key)
+        get(key, :float)
+      end
+
+      # For compatibility with htslib.cr.
+      def get_flag(key)
+        get(key, :flag)
+      end
+
+      # For compatibility with htslib.cr.
+      def get_string(key)
+        get(key, :string)
+      end
+
+      def [](key)
+        get(key)
+      end
+
       def get(key, type = nil)
         n = FFI::MemoryPointer.new(:int)
         p1 = @p1
-        h = @record.bcf.header.struct
+        h = @record.header.struct
         r = @record.struct
 
         format_values = proc do |type|
@@ -25,7 +45,15 @@ module HTS
           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)
@@ -33,21 +61,85 @@ module HTS
           format_values.call(LibHTS::BCF_HT_REAL)
                        .read_array_of_float(n.read_int)
         when :flag
-          format_values.call(LibHTS::BCF_HT_FLAG)
-                       .read_int == 1
+          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."
-          format_values.call(LibHTS::BCF_HT_STR)
-                       .read_string
+          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: name,
+            n: num,
+            type: ht_type_to_sym(type),
+            id: id
+          }
+        end
+      end
 
-      # def fields # iterator
-      # end
+      def length
+        @record.struct[:n_fmt]
+      end
 
-      def genotypes; 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
+
+      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

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 module HTS
-  class Bcf
+  class Bcf < Hts
     class Header
-      def initialize(bcf_hdr)
-        @bcf_hdr = bcf_hdr
+      def initialize(hts_file)
+        @bcf_hdr = LibHTS.bcf_hdr_read(hts_file)
       end
 
       def struct
@@ -15,12 +15,33 @@ module HTS
         @bcf_hdr.to_ptr
       end
 
+      def get_version
+        LibHTS.bcf_hdr_get_version(@bcf_hdr)
+      end
+
+      def nsamples
+        LibHTS.bcf_hdr_nsamples(@bcf_hdr)
+      end
+
+      def samples
+        # bcf_hdr_id2name is macro function
+        @bcf_hdr[:samples]
+          .read_array_of_pointer(nsamples)
+          .map(&:read_string)
+      end
+
       def to_s
         kstr = LibHTS::KString.new
         raise "Failed to get header string" unless LibHTS.bcf_hdr_format(@bcf_hdr, 0, kstr)
 
         kstr[:s]
       end
+
+      private
+
+      def initialize_copy(orig)
+        @bcf_hdr = LibHTS.bcf_hdr_dup(orig.struct)
+      end
     end
   end
 end

data/lib/hts/bcf/info.rb

@@ -1,27 +1,52 @@
 # frozen_string_literal: true
 
 module HTS
-  class Bcf
+  class Bcf < Hts
     class Info
       def initialize(record)
         @record = record
+        @p1 = FFI::MemoryPointer.new(:pointer) # FIXME: naming
+      end
+
+      # For compatibility with htslib.cr.
+      def get_int(key)
+        get(key, :int)
+      end
+
+      # For compatibility with htslib.cr.
+      def get_float(key)
+        get(key, :float)
+      end
+
+      # For compatibility with htslib.cr.
+      def get_string(key)
+        get(key, :string)
+      end
+
+      # For compatibility with htslib.cr.
+      def get_flag(key)
+        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)
-        p1 = @record.p1
-        h = @record.bcf.header.struct
+        p1 = @p1
+        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
@@ -46,47 +71,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.bcf.header.struct, LibHTS::BCF_DT_ID, fld[:key]
-            ),
-            n: LibHTS.bcf_hdr_id2number(
-              @record.bcf.header.struct, LibHTS::BCF_HL_INFO, fld[:key]
-            ),
-            vtype: fld[:type], i: fld[:key]
+            name: name,
+            n: num,
+            type: ht_type_to_sym(type),
+            key: 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.bcf.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