htslib 0.0.8 → 0.2.0

data/lib/hts/bam.rb

@@ -1,21 +1,22 @@
 # 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"
 require_relative "bam/record"
 
 module HTS
+  # A class for working with SAM, BAM, CRAM files.
   class Bam
     include Enumerable
 
-    attr_reader :file_path, :mode, :header
+    attr_reader :file_name, :index_name, :mode, :header
 
-    def self.open(...)
-      file = new(...)
+    def self.open(*args, **kw)
+      file = new(*args, **kw) # do not yield
       return file unless block_given?
 
       begin
@@ -26,112 +27,123 @@ module HTS
       file
     end
 
-    def initialize(filename, mode = "r", fai: nil, threads: nil, index: nil)
-      raise "HTS::Bam.new() dose not take block; Please use HTS::Bam.open() instead" if block_given?
-
-      @file_path = filename == "-" ? "-" : File.expand_path(filename)
-
-      if mode[0] == "r" && !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
 
-      @mode      = mode
-      @hts_file  = LibHTS.hts_open(file_path, mode)
+      # 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
-        fai_path = File.expand_path(fai)
-        r = LibHTS.hts_set_fai_filename(@hts_file, fai_path)
+        r = LibHTS.hts_set_fai_filename(@hts_file, fai)
         raise "Failed to load fasta index: #{fai}" if r < 0
       end
 
-      if threads&.> 0
-        r = LibHTS.hts_set_threads(@hts_file, threads)
-        raise "Failed to set number of threads: #{threads}" if r < 0
-      end
+      set_threads(threads) if threads
 
-      return if mode[0] == "w"
+      return if @mode[0] == "w"
 
       @header = Bam::Header.new(@hts_file)
+      create_index(index) if create_index
+      @idx = load_index(index)
+      @start_position = tell
+      super # do nothing
+    end
 
-      create_index if index
+    def create_index(index_name = nil)
+      check_closed
 
-      # load index
-      @idx = LibHTS.sam_index_load(@hts_file, file_path)
+      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 create_index
-      warn "Create index for #{file_path}"
-      LibHTS.sam_index_build(file_path, -1)
-      idx = LibHTS.sam_index_load(@hts_file, file_path)
-      raise "Failed to load index: #{file_path}" if idx.null?
-    end
+    def load_index(index_name = nil)
+      check_closed
 
-    def struct
-      @hts_file
+      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 to_ptr
-      @hts_file.to_ptr
+    def index_loaded?
+      check_closed
+
+      !@idx.null?
     end
 
     # Close the current file.
     def close
-      LibHTS.hts_idx_destroy(@idx) if @idx
+      LibHTS.hts_idx_destroy(@idx) if @idx&.null?
       @idx = nil
-      LibHTS.hts_close(@hts_file)
-      @hts_file = nil
-    end
-
-    def closed?
-      @hts_file.nil?
+      super
     end
 
     def write_header(header)
+      check_closed
+
       @header = header.dup
-      LibHTS.hts_set_fai_filename(@hts_file, @file_path)
+      LibHTS.hts_set_fai_filename(@hts_file, @file_name)
       LibHTS.sam_hdr_write(@hts_file, header)
     end
 
     def write(aln)
+      check_closed
+
       aln_dup = aln.dup
       LibHTS.sam_write1(@hts_file, header, aln_dup) > 0 || raise
     end
 
-    # Flush the current file.
-    def flush
-      # LibHTS.bgzf_flush(@@hts_file.fp.bgzf)
+    def each(copy: false, &block)
+      if copy
+        each_record_copy(&block)
+      else
+        each_record_reuse(&block)
+      end
     end
 
-    # Iterate over each record.
-    # Record object is reused.
-    # Faster than each_copy.
-    def each
-      # 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.
+    private def each_record_copy
+      check_closed
       return to_enum(__method__) unless block_given?
 
-      bam1 = LibHTS.bam_init1
-      record = Record.new(bam1, header)
-      yield record while LibHTS.sam_read1(@hts_file, header, bam1) > 0
+      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.
-    # Generate a new Record object each time.
-    # Slower than each.
-    def each_copy
+    private def each_record_reuse
+      check_closed
+      # Each does not always start at the beginning of the file.
+      # This is the common behavior of IO objects in Ruby.
       return to_enum(__method__) unless block_given?
 
-      while LibHTS.sam_read1(@hts_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)
-      # FIXME: when @idx is nil
+      check_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
@@ -145,5 +157,63 @@ module HTS
         LibHTS.hts_itr_destroy(qiter)
       end
     end
+
+    # @!macro [attach] define_getter
+    #   @method $1
+    #   Get $1 array
+    #   @return [Array] the $1 array
+    define_getter :qname
+    define_getter :flag
+    define_getter :chrom
+    define_getter :pos
+    define_getter :mapq
+    define_getter :cigar
+    define_getter :mate_chrom
+    define_getter :mate_pos
+    define_getter :insert_size
+    define_getter :seq
+    define_getter :qual
+
+    alias isize insert_size
+    alias mpos mate_pos
+
+    def aux(tag)
+      warn "experimental"
+      check_closed
+      position = tell
+      ary = map { |r| r.aux(tag) }
+      seek(position)
+      ary
+    end
+
+    # @!macro [attach] define_iterator
+    #   @method each_$1
+    #   Get $1 iterator
+    define_iterator :qname
+    define_iterator :flag
+    define_iterator :chrom
+    define_iterator :pos
+    define_iterator :mapq
+    define_iterator :cigar
+    define_iterator :mate_chrom
+    define_iterator :mate_pos
+    define_iterator :insert_size
+    define_iterator :seq
+    define_iterator :qual
+
+    alias each_isize each_insert_size
+    alias each_mpos each_mate_pos
+
+    def each_aux(tag)
+      warn "experimental"
+      check_closed
+      return to_enum(__method__, tag) unless block_given?
+
+      each do |record|
+        yield record.aux(tag)
+      end
+
+      self
+    end
   end
 end

data/lib/hts/bcf/format.rb

@@ -1,11 +1,7 @@
 # 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
@@ -32,20 +28,32 @@ module HTS
         get(key, :string)
       end
 
+      def [](key)
+        get(key)
+      end
+
       def get(key, type = nil)
         n = FFI::MemoryPointer.new(:int)
         p1 = @p1
         h = @record.header.struct
         r = @record.struct
 
-        format_values = proc do |type|
-          ret = LibHTS.bcf_get_format_values(h, r, key, p1, n, type)
+        format_values = proc do |typ|
+          ret = LibHTS.bcf_get_format_values(h, r, key, p1, n, typ)
           return nil if ret < 0 # return from method.
 
           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)
@@ -53,22 +61,85 @@ module HTS
           format_values.call(LibHTS::BCF_HT_REAL)
                        .read_array_of_float(n.read_int)
         when :flag
-          raise NotImplementedError, "Flag type not implemented yet."
+          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."
+          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:,
+            n: num,
+            type: ht_type_to_sym(type),
+            id:
+          }
+        end
+      end
 
-      # def fields # iterator
-      # end
+      def length
+        @record.struct[:n_fmt]
+      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
+      # 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,7 +1,8 @@
 # frozen_string_literal: true
 
 module HTS
-  class Bcf
+  class Bcf < Hts
+    # A class for working with VCF records.
     class Header
       def initialize(hts_file)
         @bcf_hdr = LibHTS.bcf_hdr_read(hts_file)
@@ -19,14 +20,14 @@ module HTS
         LibHTS.bcf_hdr_get_version(@bcf_hdr)
       end
 
-      def sample_count
+      def nsamples
         LibHTS.bcf_hdr_nsamples(@bcf_hdr)
       end
 
-      def sample_names
+      def samples
         # bcf_hdr_id2name is macro function
         @bcf_hdr[:samples]
-          .read_array_of_pointer(sample_count)
+          .read_array_of_pointer(nsamples)
           .map(&:read_string)
       end
 

data/lib/hts/bcf/info.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 module HTS
-  class Bcf
+  class Bcf < Hts
+    # Info field
     class Info
       def initialize(record)
         @record = record
@@ -28,6 +29,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 +40,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 +72,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:,
+            n: num,
+            type: ht_type_to_sym(type),
+            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