htslib 0.0.5 → 0.0.10

data/lib/hts/bcf/header.rb

@@ -1,18 +1,46 @@
 # frozen_string_literal: true
 
 module HTS
-  class Bcf
+  class Bcf < Hts
     class Header
-      def initialize(h)
-        @h = h
+      def initialize(hts_file)
+        @bcf_hdr = LibHTS.bcf_hdr_read(hts_file)
       end
 
       def struct
-        @h
+        @bcf_hdr
       end
 
       def to_ptr
-        @h.to_ptr
+        @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

data/lib/hts/bcf/info.rb

@@ -1,17 +1,38 @@
 # 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
 
       # @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|
@@ -44,6 +65,7 @@ module HTS
         end
       end
 
+      # FIXME: naming? room for improvement.
       def fields
         n_info = @record.struct[:n_info]
         Array.new(n_info) do |i|
@@ -53,10 +75,10 @@ module HTS
           )
           {
             name: LibHTS.bcf_hdr_int2id(
-              @record.bcf.header.struct, LibHTS::BCF_DT_ID, fld[:key]
+              @record.header.struct, LibHTS::BCF_DT_ID, fld[:key]
             ),
             n: LibHTS.bcf_hdr_id2number(
-              @record.bcf.header.struct, LibHTS::BCF_HL_INFO, fld[:key]
+              @record.header.struct, LibHTS::BCF_HL_INFO, fld[:key]
             ),
             vtype: fld[:type], i: fld[:key]
           }
@@ -72,7 +94,7 @@ module HTS
             i * LibHTS::BcfInfo.size
           )
           id = LibHTS.bcf_hdr_int2id(
-            @record.bcf.header.struct, LibHTS::BCF_DT_ID, fld[:key]
+            @record.header.struct, LibHTS::BCF_DT_ID, fld[:key]
           )
           return fld[:type] if id == key
         end

data/lib/hts/bcf/record.rb

@@ -1,22 +1,21 @@
 # frozen_string_literal: true
 
 module HTS
-  class Bcf
+  class Bcf < Hts
     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,10 +25,9 @@ module HTS
       def genotypes; end
 
       def chrom
-        hdr = @bcf.header.struct
         rid = @bcf1[:rid]
 
-        LibHTS.bcf_hdr_id2name(hdr, rid)
+        LibHTS.bcf_hdr_id2name(@header.struct, rid)
       end
 
       def pos
@@ -59,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
 
@@ -80,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
@@ -101,10 +102,17 @@ module HTS
 
       def to_s
         ksr = LibHTS::KString.new
-        raise "Failed to format record" if LibHTS.vcf_format(@bcf.header.struct, @bcf1, ksr) == -1
+        raise "Failed to format record" if LibHTS.vcf_format(@header.struct, @bcf1, ksr) == -1
 
         ksr[:s]
       end
+
+      private
+
+      def initialize_copy(orig)\
+        @header = orig.header
+        @bcf1 = LibHTS.bcf_dup(orig.struct)
+      end
     end
   end
 end

data/lib/hts/bcf.rb

@@ -3,71 +3,109 @@
 # Based on hts-python
 # https://github.com/quinlan-lab/hts-python
 
+require_relative "../htslib"
+
+require_relative "hts"
 require_relative "bcf/header"
 require_relative "bcf/info"
 require_relative "bcf/format"
 require_relative "bcf/record"
 
 module HTS
-  class Bcf
+  class Bcf < Hts
     include Enumerable
 
-    attr_reader :file_path, :mode, :header
-    # HtfFile is FFI::BitStruct
-    attr_reader :htf_file
+    attr_reader :file_name, :index_path, :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")
-      file_path = File.expand_path(file_path)
+      begin
+        yield file
+      ensure
+        file.close
+      end
+      file
+    end
 
-      unless File.exist?(file_path)
-        message = "No such VCF/BCF file - #{file_path}"
+    def initialize(file_name, mode = "r", index: nil, fai: nil, threads: nil,
+                   create_index: false)
+      if block_given?
+        message = "HTS::Bcf.new() dose not take block; Please use HTS::Bcf.open() instead"
         raise message
       end
 
-      @file_path = file_path
+      # NOTE: Do not check for the existence of local files, since file_names may be remote URIs.
+
+      @file_name = file_name
       @mode      = mode
-      @htf_file  = LibHTS.hts_open(file_path, mode)
-      @header    = Bcf::Header.new(LibHTS.bcf_hdr_read(htf_file))
+      @hts_file  = LibHTS.hts_open(@file_name, mode)
 
-      # IO like API
-      if block_given?
-        begin
-          yield self
-        ensure
-          close
-        end
+      raise Errno::ENOENT, "Failed to open #{@file_name}" if @hts_file.null?
+
+      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
+    def write_header
+      @header = header.dup
+      LibHTS.hts_set_fai_filename(header, @file_name)
+      LibHTS.bcf_hdr_write(@hts_file, header.struct)
     end
 
-    def to_ptr
-      htf_file.to_ptr
+    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
+    def closed?
+      @hts_file.nil?
+    end
+
+    def nsamples
+      header.nsamples
+    end
+
+    def samples
+      header.samples
+    end
+
+    # Iterate over each record.
+    # Generate a new Record object each time.
+    # Slower than each.
+    def each_copy
       return to_enum(__method__) unless block_given?
 
-      while LibHTS.bcf_read(htf_file, header, bcf1 = LibHTS.bcf_init) != -1
-        record = Record.new(bcf1, self)
+      while LibHTS.bcf_read(@hts_file, header, bcf1 = LibHTS.bcf_init) != -1
+        record = Record.new(bcf1, header)
         yield record
       end
       self
     end
 
-    def n_samples
-      LibHTS.bcf_hdr_nsamples(header.struct)
+    # Iterate over each record.
+    # Record object is reused.
+    # Faster than each_copy.
+    def each
+      return to_enum(__method__) unless block_given?
+
+      bcf1 = LibHTS.bcf_init
+      record = Record.new(bcf1, header)
+      yield record while LibHTS.bcf_read(@hts_file, header, bcf1) != -1
+      self
     end
   end
 end

data/lib/hts/faidx.rb

@@ -3,17 +3,19 @@
 # Based on hts-python
 # https://github.com/quinlan-lab/hts-python
 
+require_relative "../htslib"
+
 module HTS
   class Faidx
-    attr_reader :file_path
+    attr_reader :file_name
 
     class << self
       alias open new
     end
 
-    def initialize(file_path)
-      @file_path = File.expand_path(file_path)
-      @fai = LibHTS.fai_load(file_path)
+    def initialize(file_name)
+      @file_name = file_name
+      @fai = LibHTS.fai_load(@file_name)
 
       # IO like API
       if block_given?

data/lib/hts/ffi_ext/struct.rb

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

data/lib/hts/hts.rb

@@ -0,0 +1,56 @@
+require_relative "../htslib"
+
+module HTS
+  class Hts
+    def struct
+      @hts_file
+    end
+
+    def to_ptr
+      @hts_file.to_ptr
+    end
+
+    def format
+      LibHTS.hts_get_format(@hts_file)[:format].to_s
+    end
+
+    def format_version
+      v = LibHTS.hts_get_format(@hts_file)[:version]
+      major = v[:major]
+      minor = v[:minor]
+      if minor == -1
+        major.to_s
+      else
+        "#{major}.#{minor}"
+      end
+    end
+    
+    def seek(offset)
+      if @hts_file[:is_cram] == 1
+        LibHTS.cram_seek(@hts_file[:fp][:cram], offset, IO::SEEK_SET)
+      elsif @hts_file[:is_bgzf] == 1
+        LibHTS.bgzf_seek(@hts_file[:fp][:bgzf], offset, IO::SEEK_SET)
+      else
+        LibHTS.hseek(@hts_file[:fp][:hfile], offset, IO::SEEK_SET)
+      end
+    end
+
+    def tell
+      if @hts_file[:is_cram] == 1
+        # LibHTS.cram_tell(@hts_file[:fp][:cram])
+        # warn 'cram_tell is not implemented in c htslib'
+        nil
+      elsif @hts_file[:is_bgzf] == 1
+        LibHTS.bgzf_tell(@hts_file[:fp][:bgzf])
+      else
+        LibHTS.htell(@hts_file[:fp][:hfile])
+      end
+    end
+
+    def rewind
+      r = seek(@start_position) if @start_position
+      raise "Failed to rewind: #{r}" if r < 0
+      r 
+    end
+  end
+end

data/lib/hts/libhts/bgzf.rb

@@ -18,19 +18,19 @@ module HTS
     # Open an existing hFILE stream for reading or writing.
     attach_function \
       :bgzf_hopen,
-      %i[HFILE string],
+      [HFILE, :string],
       BGZF.by_ref
 
     # Close the BGZF and free all associated resources.
     attach_function \
       :bgzf_close,
-      [:HFILE],
+      [HFILE],
       :int
 
     # Read up to _length_ bytes from the file storing into _data_.
     attach_function \
       :bgzf_read,
-      %i[HFILE pointer size_t],
+      [HFILE, :pointer, :size_t],
       :ssize_t
 
     # Write _length_ bytes from _data_ to the file. If no I/O errors occur,
@@ -75,6 +75,11 @@ module HTS
       [BGZF],
       :int
 
+    # Return a virtual file pointer to the current location in the file.
+    def self.bgzf_tell(fp)
+      (fp[:block_address] << 16) | (fp[:block_offset] & 0xFFFF)
+    end
+
     # Set the file to read from the location specified by _pos_.
     attach_function \
       :bgzf_seek,
@@ -176,7 +181,7 @@ module HTS
     # Load BGZF index from an hFILE
     attach_function \
       :bgzf_index_load_hfile,
-      [BGZF, :HFILE, :string],
+      [BGZF, HFILE, :string],
       :int
 
     # Save BGZF index
@@ -188,7 +193,7 @@ module HTS
     # Write a BGZF index to an hFILE
     attach_function \
       :bgzf_index_dump_hfile,
-      [BGZF, :HFILE, :string],
+      [BGZF, HFILE, :string],
       :int
   end
 end

data/lib/hts/libhts/constants.rb

@@ -2,7 +2,6 @@
 
 module HTS
   module LibHTS
-    typedef :pointer, :HFILE
     typedef :int64, :hts_pos_t
     typedef :pointer, :bam_plp_auto_f
 
@@ -25,6 +24,25 @@ module HTS
         :f,              :pointer # kstream_t
     end
 
+    # HFILE
+
+    class HFILE < FFI::BitStruct
+      layout \
+        :buffer,        :string,
+        :begin,         :string,
+        :end,           :string,
+        :limit,         :string,
+        :backend,       :pointer,
+        :offset,        :size_t,
+        :_flags,        :uint,
+        :has_errno,     :int
+      
+      bit_fields :_flags,
+                 :at_eof,     1,
+                 :mobile,     1,
+                 :readonly,   1
+    end
+
     # BGZF
     class BGZF < FFI::BitStruct
       layout \
@@ -38,7 +56,7 @@ module HTS
         :uncompressed_block,     :pointer,
         :compressed_block,       :pointer,
         :cache,                  :pointer,
-        :fp,                     :HFILE,
+        :fp,                     HFILE.ptr,
         :mt,                     :pointer,
         :idx,                    :pointer,
         :idx_build_otf,          :int,
@@ -198,8 +216,8 @@ module HTS
         :fp,
         union_layout(
           :bgzf,         BGZF.ptr,
-          :cram,         :pointer,
-          :hfile,        :pointer # HFILE
+          :cram,         :pointer, # cram_fd
+          :hfile,        HFILE.ptr
         ),
         :state,          :pointer,
         :format,         HtsFormat,
@@ -218,7 +236,7 @@ module HTS
 
     SamFile = HtsFile
 
-    class HtsThreadPool < FFI::Struct
+    class HtsTpool < FFI::Struct
       layout \
         :pool,           :pointer,
         :qsize,          :int