htslib 0.0.6 → 0.1.0

data/lib/hts/bcf/record.rb

@@ -1,15 +1,14 @@
 # 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
@@ -19,36 +18,48 @@ 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
-        hdr = @bcf.header.struct
-        rid = @bcf1[:rid]
-
-        LibHTS.bcf_hdr_id2name(hdr, 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 id=(id)
+        LibHTS.bcf_update_id(@header, @bcf1, id)
+      end
+
+      def clear_id
+        LibHTS.bcf_update_id(@header, @bcf1, ".")
+      end
+
       def filter
         LibHTS.bcf_unpack(@bcf1, LibHTS::BCF_UN_FLT)
         d = @bcf1[:d]
@@ -59,20 +70,25 @@ module HTS
           "PASS"
         when 1
           i = d[:flt].read_int
-          LibHTS.bcf_hdr_int2id(@bcf.header.struct, LibHTS::BCF_DT_ID, i)
-        when 2
+          LibHTS.bcf_hdr_int2id(@header.struct, LibHTS::BCF_DT_ID, i)
+        when 2..nil
           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
 
+      # Get variant quality.
       def qual
         @bcf1[:qual]
       end
 
+      def qual=(qual)
+        @bcf1[:qual] = qual
+      end
+
       def ref
         LibHTS.bcf_unpack(@bcf1, LibHTS::BCF_UN_STR)
         @bcf1[:d][:allele].get_pointer(0).read_string
@@ -92,22 +108,38 @@ module HTS
         ).map(&:read_string)
       end
 
-      def info
+      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
         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

@@ -1,73 +1,136 @@
 # frozen_string_literal: true
 
-# 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_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")
-      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
-      @mode      = mode
-      @htf_file  = LibHTS.hts_open(file_path, mode)
-      @header    = Bcf::Header.new(LibHTS.bcf_hdr_read(htf_file))
+      # NOTE: Do not check for the existence of local files, since file_names may be remote URIs.
 
-      # IO like API
-      if block_given?
-        begin
-          yield self
-        ensure
-          close
-        end
+      @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 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)
+
+      create_index(index) if create_index
+
+      @idx = load_index(index)
+
+      @start_position = tell
+    end
+
+    def create_index(index_name = nil)
+      warn "Create index for #{@file_name} to #{index_name}"
+      if index
+        LibHTS.bcf_index_build2(@hts_file, index_name, -1)
+      else
+        LibHTS.bcf_index_build(@hts_file, -1)
+      end
+    end
+
+    def load_index(index_name = nil)
+      if index_name
+        LibHTS.bcf_index_load2(@file_name, index_name)
+      else
+        LibHTS.bcf_index_load3(@file_name, nil, 2)
       end
     end
 
-    def struct
-      htf_file
+    def index_loaded?
+      !@idx.null?
+    end
+
+    def write_header
+      raise IOError, "closed stream" if closed?
+
+      @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)
+      raise IOError, "closed stream" if closed?
+
+      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)
+
+    def nsamples
+      header.nsamples
     end
 
-    def each
+    def samples
+      header.samples
+    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.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 sample_count
-      LibHTS.bcf_hdr_nsamples(header.struct)
+    # Iterate over each record.
+    # Record object is reused.
+    # Faster than each_copy.
+    def each
+      raise IOError, "closed stream" if closed?
+
+      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

@@ -1,19 +1,18 @@
 # frozen_string_literal: true
 
-# 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/pointer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module FFI
+  class Pointer
+    unless method_defined?(:read_array_of_struct)
+      def read_array_of_struct(type, length)
+        ary = []
+        size = type.size
+        tmp = self
+        length.times do |j|
+          ary << type.new(tmp)
+          tmp += size unless j == length - 1 # avoid OOB
+        end
+        ary
+      end
+    end
+  end
+end

data/lib/hts/hts.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+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 close
+      return if closed?
+
+      LibHTS.hts_close(@hts_file)
+      @hts_file = nil
+    end
+
+    def closed?
+      @hts_file.nil? || @hts_file.null?
+    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
+      if @start_position
+        r = seek(@start_position)
+        raise "Failed to rewind: #{r}" if r < 0
+
+        tell
+      else
+        raise "Cannot rewind: no start position"
+      end
+    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
@@ -461,8 +479,8 @@ module HTS
         :id,             :string,
         :als,            :pointer, # (\\0-separated string)
         :allele,         :pointer,
-        :info,           :pointer, # BcfInfo.ptr,
-        :fmt,            BcfFmt.ptr,
+        :info,           :pointer, # array of BcfInfo.ptr,
+        :fmt,            :pointer, # array of BcfFmt.ptr,
         :var,            BcfVariant.ptr,
         :n_var,          :int,
         :var_type,       :int,