htslib 0.0.10 → 0.1.0

data/lib/hts/bcf/info.rb

@@ -28,6 +28,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 +39,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 +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.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: 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.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

@@ -18,35 +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
-        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 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]
@@ -58,7 +71,7 @@ module HTS
         when 1
           i = d[:flt].read_int
           LibHTS.bcf_hdr_int2id(@header.struct, LibHTS::BCF_DT_ID, i)
-        when 2
+        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
@@ -67,10 +80,15 @@ module HTS
         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
@@ -90,14 +108,23 @@ 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

data/lib/hts/bcf.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"
@@ -15,7 +12,7 @@ module HTS
   class Bcf < Hts
     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 +35,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?
 
@@ -52,28 +50,51 @@ module HTS
       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 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 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(@hts_file)
-      @hts_file = nil
-    end
-
-    def closed?
-      @hts_file.nil?
-    end
 
     def nsamples
       header.nsamples
@@ -87,6 +108,8 @@ module HTS
     # 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(@hts_file, header, bcf1 = LibHTS.bcf_init) != -1
@@ -100,6 +123,8 @@ module HTS
     # 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

data/lib/hts/faidx.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-# Based on hts-python
-# https://github.com/quinlan-lab/hts-python
-
 require_relative "../htslib"
 
 module HTS

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "../htslib"
 
 module HTS
@@ -24,7 +26,18 @@ module HTS
         "#{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)
@@ -48,9 +61,14 @@ module HTS
     end
 
     def rewind
-      r = seek(@start_position) if @start_position
-      raise "Failed to rewind: #{r}" if r < 0
-      r 
+      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/constants.rb

@@ -36,7 +36,7 @@ module HTS
         :offset,        :size_t,
         :_flags,        :uint,
         :has_errno,     :int
-      
+
       bit_fields :_flags,
                  :at_eof,     1,
                  :mobile,     1,
@@ -479,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,