htslib 0.0.4 → 0.0.8

data/lib/hts/bcf/info.rb

@@ -5,12 +5,34 @@ module 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
+
+      # @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|
@@ -20,19 +42,72 @@ module HTS
           p1.read_pointer
         end
 
-        case type.to_sym
+        type ||= info_type_to_string(get_info_type(key))
+
+        case type&.to_sym
         when :int, :int32
           info_values.call(LibHTS::BCF_HT_INT)
                      .read_array_of_int32(n.read_int)
         when :float, :real
           info_values.call(LibHTS::BCF_HT_REAL)
                      .read_array_of_float(n.read_int)
-        when :flag
-          info_values.call(LibHTS::BCF_HT_FLAG)
-                     .read_int == 1
+        when :flag, :bool
+          case ret = LibHTS.bcf_get_info_flag(h, r, key, p1, n)
+          when 1 then true
+          when 0 then false
+          when -1 then nil
+          else
+            raise "Unknown return value from bcf_get_info_flag: #{ret}"
+          end
         when :string, :str
           info_values.call(LibHTS::BCF_HT_STR)
-                     .read_pointer.read_string
+                     .read_string
+        end
+      end
+
+      # 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
+          )
+          {
+            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]
+          }
+        end
+      end
+
+      private
+
+      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
+        end
+      end
+
+      def info_type_to_string(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}"
         end
       end
     end

data/lib/hts/bcf/record.rb

@@ -3,20 +3,19 @@
 module HTS
   class Bcf
     class Record
-      def initialize(bcf_t, bcf)
+      def initialize(bcf_t, header)
         @bcf1 = bcf_t
-        @bcf = bcf
-        @p1 = FFI::MemoryPointer.new(:pointer) # FIXME: naming
+        @header = header
       end
 
-      attr_reader :p1, :bcf
+      attr_reader :header
 
       def struct
         @bcf1
       end
 
       def to_ptr
-        @bcf.to_ptr
+        @bcf1.to_ptr
       end
 
       # def inspect; end
@@ -26,15 +25,9 @@ module HTS
       def genotypes; end
 
       def chrom
-        hdr = @bcf.header.struct
         rid = @bcf1[:rid]
 
-        return nil if hdr.null? || rid < 0 || rid >= hdr[:n][LibHTS::BCF_DT_CTG]
-
-        LibHTS::BcfIdpair.new(
-          hdr[:id][LibHTS::BCF_DT_CTG].to_ptr +
-          LibHTS::BcfIdpair.size * rid # offset
-        )[:key]
+        LibHTS.bcf_hdr_id2name(@header.struct, rid)
       end
 
       def pos
@@ -64,11 +57,13 @@ module HTS
           "PASS"
         when 1
           i = d[:flt].read_int
-          LibHTS.bcf_hdr_int2id(@bcf.header.struct, LibHTS::BCF_DT_ID, i)
+          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(@bcf.header.struct, LibHTS::BCF_DT_ID, 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
 
@@ -85,13 +80,14 @@ module HTS
         LibHTS.bcf_unpack(@bcf1, LibHTS::BCF_UN_STR)
         @bcf1[:d][:allele].get_array_of_pointer(
           FFI::TYPE_POINTER.size, @bcf1[:n_allele] - 1
-        ).map { |c| c.read_string }
+        ).map(&:read_string)
       end
 
       def alleles
+        LibHTS.bcf_unpack(@bcf1, LibHTS::BCF_UN_STR)
         @bcf1[:d][:allele].get_array_of_pointer(
           0, @bcf1[:n_allele]
-        ).map { |c| c.read_string }
+        ).map(&:read_string)
       end
 
       def info
@@ -106,11 +102,16 @@ module HTS
 
       def to_s
         ksr = LibHTS::KString.new
-        if LibHTS.vcf_format(@bcf.header.struct, @bcf1, ksr) == -1
-          raise "Failed to format record"
-        end
+        raise "Failed to format record" if LibHTS.vcf_format(@header.struct, @bcf1, ksr) == -1
+
         ksr[:s]
       end
+
+      private
+
+      def initialize_copy
+        raise "Not implemented"
+      end
     end
   end
 end

data/lib/hts/bcf.rb

@@ -4,72 +4,96 @@
 # https://github.com/quinlan-lab/hts-python
 
 require_relative "bcf/header"
-require_relative "bcf/record"
 require_relative "bcf/info"
 require_relative "bcf/format"
-require_relative "utils/open_method"
+require_relative "bcf/record"
 
 module HTS
   class Bcf
     include Enumerable
-    extend Utils::OpenMethod
 
     attr_reader :file_path, :mode, :header
-    # HtfFile is FFI::BitStruct
-    attr_reader :htf_file
 
-    class << self
-      alias open new
+    def self.open(...)
+      file = new(...)
+      return file unless block_given?
+
+      begin
+        yield file
+      ensure
+        file.close
+      end
+      file
     end
 
-    def initialize(file_path, mode = "r")
-      file_path = File.expand_path(file_path)
+    def initialize(filename, mode = "r", threads: nil)
+      raise "HTS::Bcf.new() dose not take block; Please use HTS::Bcf.open() instead" if block_given?
+
+      @file_path = filename == "-" ? "-" : File.expand_path(filename)
 
-      unless File.exist?(file_path)
+      if mode[0] == "r" && !File.exist?(file_path)
         message = "No such VCF/BCF file - #{file_path}"
         raise message
       end
 
-      @file_path = file_path
       @mode      = mode
-      @htf_file  = LibHTS.hts_open(file_path, mode)
-      @header    = Bcf::Header.new(LibHTS.bcf_hdr_read(htf_file))
-
-      # FIXME: should be defined here?
-      @bcf1      = LibHTS.bcf_init
-
-      # IO like API
-      if block_given?
-        begin
-          yield self
-        ensure
-          close
-        end
+      @hts_file  = LibHTS.hts_open(file_path, mode)
+
+      if threads&.> 0
+        r = LibHTS.hts_set_threads(@hts_file, threads)
+        raise "Failed to set number of threads: #{threads}" if r < 0
       end
+
+      return if mode[0] == "w"
+
+      @header = Bcf::Header.new(@hts_file)
     end
 
     def struct
-      htf_file
+      @hts_file
     end
 
     def to_ptr
-      htf_file.to_ptr
+      @hts_file.to_ptr
+    end
+
+    def write_header
+      @header = header.dup
+      LibHTS.hts_set_fai_filename(header, @file_path)
+      LibHTS.bcf_hdr_write(@hts_file, header.struct)
+    end
+
+    def write(var)
+      var_dup = var.dup = var.dup
+      LibHTS.bcf_write(@hts_file, header, var_dup) > 0 || raise
     end
 
     # Close the current file.
     def close
-      LibHTS.hts_close(htf_file)
+      LibHTS.hts_close(@hts_file)
+      @hts_file = nil
     end
 
-    def each(&block)
-      while LibHTS.bcf_read(htf_file, header, @bcf1) != -1
-        record = Record.new(@bcf1, self)
-        block.call(record)
-      end
+    def closed?
+      @hts_file.nil?
+    end
+
+    def sample_count
+      header.sample_count
     end
 
-    def n_samples
-      LibHTS.bcf_hdr_nsamples(header.struct)
+    def sample_names
+      header.sample_names
+    end
+
+    def each
+      return to_enum(__method__) unless block_given?
+
+      while LibHTS.bcf_read(@hts_file, header, bcf1 = LibHTS.bcf_init) != -1
+        record = Record.new(bcf1, header)
+        yield record
+      end
+      self
     end
   end
 end

data/lib/hts/faidx.rb

@@ -3,17 +3,26 @@
 # Based on hts-python
 # https://github.com/quinlan-lab/hts-python
 
-require_relative "utils/open_method"
-
 module HTS
   class Faidx
-    extend Utils::OpenMethod
-
     attr_reader :file_path
 
+    class << self
+      alias open new
+    end
+
     def initialize(file_path)
       @file_path = File.expand_path(file_path)
       @fai = LibHTS.fai_load(file_path)
+
+      # IO like API
+      if block_given?
+        begin
+          yield self
+        ensure
+          close
+        end
+      end
     end
 
     def close

data/lib/hts/ffi_ext/struct.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "ffi/bit_struct"
+require "ffi/bit_field"
 
 module FFI
   class Struct

data/lib/hts/libhts/constants.rb

@@ -218,7 +218,7 @@ module HTS
 
     SamFile = HtsFile
 
-    class HtsThreadPool < FFI::Struct
+    class HtsTpool < FFI::Struct
       layout \
         :pool,           :pointer,
         :qsize,          :int
@@ -289,7 +289,7 @@ module HTS
         :isize,          :hts_pos_t
     end
 
-    class Bam1 < FFI::Struct
+    class Bam1 < FFI::ManagedStruct
       layout \
         :core,           Bam1Core,
         :id,             :uint64,
@@ -301,6 +301,10 @@ module HTS
       # bit_fields :_mempolicy,
       #            :mempolicy,  2,
       #            :_reserved,  30
+
+      def self.release(ptr)
+        LibHTS.bam_destroy1(ptr) unless ptr.null?
+      end
     end
 
     typedef :pointer, :bam_plp
@@ -457,7 +461,7 @@ module HTS
         :id,             :string,
         :als,            :pointer, # (\\0-separated string)
         :allele,         :pointer,
-        :info,           BcfInfo.ptr,
+        :info,           :pointer, # BcfInfo.ptr,
         :fmt,            BcfFmt.ptr,
         :var,            BcfVariant.ptr,
         :n_var,          :int,
@@ -466,7 +470,7 @@ module HTS
         :indiv_dirty,    :int
     end
 
-    class Bcf1 < FFI::BitStruct
+    class Bcf1 < FFI::ManagedBitStruct
       layout \
         :pos,            :hts_pos_t,
         :rlen,           :hts_pos_t,
@@ -489,6 +493,10 @@ module HTS
       bit_fields :_n_fmt_sample,
                  :n_fmt,    8,
                  :n_sample, 24
+
+      def self.release(ptr)
+        LibHTS.bcf_destroy(ptr) unless ptr.null?
+      end
     end
   end
 end

data/lib/hts/libhts/hts.rb

@@ -89,6 +89,12 @@ module HTS
       %i[HFILE string string],
       HtsFile.by_ref
 
+    # For output streams, flush any buffered data
+    attach_function \
+      :hts_flush,
+      [HtsFile],
+      :int
+
     # Close a file handle, flushing buffered data for output streams
     attach_function \
       :hts_close,
@@ -139,7 +145,7 @@ module HTS
     # Create extra threads to aid compress/decompression for this file
     attach_function \
       :hts_set_thread_pool,
-      [HtsFile, HtsThreadPool],
+      [HtsFile, HtsTpool],
       :int
 
     # Adds a cache of decompressed blocks, potentially speeding up seeks.