htslib 0.0.8 → 0.2.0

data/lib/hts/bcf/record.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 module HTS
-  class Bcf
+  class Bcf < Hts
+    # A class for working with VCF records.
     class Record
       def initialize(bcf_t, header)
         @bcf1 = bcf_t
@@ -18,57 +19,46 @@ 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 filter
-        LibHTS.bcf_unpack(@bcf1, LibHTS::BCF_UN_FLT)
-        d = @bcf1[:d]
-        n_flt = d[:n_flt]
-
-        case n_flt
-        when 0
-          "PASS"
-        when 1
-          i = d[:flt].read_int
-          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(@header.struct, LibHTS::BCF_DT_ID, i)
-          end
-        else
-          raise "Unexpected number of filters. n_flt: #{n_flt}"
-        end
+      def id=(id)
+        LibHTS.bcf_update_id(@header, @bcf1, id)
       end
 
-      def qual
-        @bcf1[:qual]
+      def clear_id
+        LibHTS.bcf_update_id(@header, @bcf1, ".")
       end
 
       def ref
@@ -90,14 +80,52 @@ module HTS
         ).map(&:read_string)
       end
 
-      def info
+      # Get variant quality.
+      def qual
+        @bcf1[:qual]
+      end
+
+      def qual=(qual)
+        @bcf1[:qual] = qual
+      end
+
+      def filter
+        LibHTS.bcf_unpack(@bcf1, LibHTS::BCF_UN_FLT)
+        d = @bcf1[:d]
+        n_flt = d[:n_flt]
+
+        case n_flt
+        when 0
+          "PASS"
+        when 1
+          id = d[:flt].read_int
+          LibHTS.bcf_hdr_int2id(@header.struct, LibHTS::BCF_DT_ID, id)
+        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
+        else
+          raise "Unexpected number of filters. n_flt: #{n_flt}"
+        end
+      end
+
+      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
@@ -109,8 +137,9 @@ module HTS
 
       private
 
-      def initialize_copy
-        raise "Not implemented"
+      def initialize_copy(orig)\
+        @header = orig.header
+        @bcf1 = LibHTS.bcf_dup(orig.struct)
       end
     end
   end

data/lib/hts/bcf.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 "bcf/header"
 require_relative "bcf/info"
 require_relative "bcf/format"
 require_relative "bcf/record"
 
 module HTS
-  class Bcf
+  # A class for working with VCF, BCF files.
+  class Bcf < Hts
     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,67 +27,100 @@ module HTS
       file
     end
 
-    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)
-
-      if mode[0] == "r" && !File.exist?(file_path)
-        message = "No such VCF/BCF file - #{file_path}"
+    def initialize(file_name, mode = "r", index: 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
 
-      @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.
 
-      if threads&.> 0
-        r = LibHTS.hts_set_threads(@hts_file, threads)
-        raise "Failed to set number of threads: #{threads}" if r < 0
-      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?
+
+      set_threads(threads) if threads
 
-      return if mode[0] == "w"
+      return if @mode[0] == "w"
 
       @header = Bcf::Header.new(@hts_file)
+      create_index(index) if create_index
+      @idx = load_index(index)
+      @start_position = tell
+      super # do nothing
     end
 
-    def struct
-      @hts_file
+    def create_index(index_name = nil)
+      check_closed
+
+      warn "Create index for #{@file_name} to #{index_name}"
+      if index_name
+        LibHTS.bcf_index_build2(@file_name, index_name, -1)
+      else
+        LibHTS.bcf_index_build(@file_name, -1)
+      end
     end
 
-    def to_ptr
-      @hts_file.to_ptr
+    def load_index(index_name = nil)
+      check_closed
+
+      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?
+      check_closed
+
+      !@idx.null?
     end
 
     def write_header
+      check_closed
+
       @header = header.dup
-      LibHTS.hts_set_fai_filename(header, @file_path)
-      LibHTS.bcf_hdr_write(@hts_file, header.struct)
+      LibHTS.hts_set_fai_filename(header, @file_name)
+      LibHTS.bcf_hdr_write(@hts_file, header)
     end
 
     def write(var)
-      var_dup = var.dup = var.dup
+      check_closed
+
+      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?
+    def nsamples
+      check_closed
+
+      header.nsamples
     end
 
-    def sample_count
-      header.sample_count
+    def samples
+      check_closed
+
+      header.samples
     end
 
-    def sample_names
-      header.sample_names
+    def each(copy: false, &block)
+      if copy
+        each_record_copy(&block)
+      else
+        each_record_reuse(&block)
+      end
     end
 
-    def each
+    private def each_record_copy
+      check_closed
+
       return to_enum(__method__) unless block_given?
 
       while LibHTS.bcf_read(@hts_file, header, bcf1 = LibHTS.bcf_init) != -1
@@ -95,5 +129,88 @@ module HTS
       end
       self
     end
+
+    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?
+
+      bcf1 = LibHTS.bcf_init
+      record = Record.new(bcf1, header)
+      yield record while LibHTS.bcf_read(@hts_file, header, bcf1) != -1
+      self
+    end
+
+    # @!macro [attach] define_getter
+    #   @method $1
+    #   Get $1 array
+    #   @return [Array] the $1 array
+    define_getter :chrom
+    define_getter :pos
+    define_getter :endpos
+    define_getter :id
+    define_getter :ref
+    define_getter :alt
+    define_getter :qual
+    define_getter :filter
+
+    def info(key = nil)
+      check_closed
+      position = tell
+      if key
+        ary = map { |r| r.info(key) }
+      else
+        raise NotImplementedError
+        # ary = each_copy.map { |r| r.info }
+        # ary = map { |r| r.info.clone }
+      end
+      seek(position)
+      ary
+    end
+
+    def format(key = nil)
+      check_closed
+      position = tell
+      if key
+        ary = map { |r| r.format(key) }
+      else
+        raise NotImplementedError
+        # ary = each_copy.map { |r| r.format }
+        # ary = map { |r| r.format.clone }
+      end
+      seek(position)
+      ary
+    end
+
+    # @!macro [attach] define_iterator
+    #   @method each_$1
+    #   Get $1 iterator
+    define_iterator :chrom
+    define_iterator :pos
+    define_iterator :endpos
+    define_iterator :id
+    define_iterator :ref
+    define_iterator :alt
+    define_iterator :qual
+    define_iterator :filter
+
+    def each_info(key)
+      check_closed
+      return to_enum(__method__) unless block
+
+      each do |r|
+        yield r.info(key)
+      end
+    end
+
+    def each_format(key)
+      check_closed
+      return to_enum(__method__) unless block
+
+      each do |r|
+        yield r.format(key)
+      end
+    end
   end
 end

data/lib/hts/faidx.rb

@@ -1,28 +1,37 @@
 # 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 self.open(*args, **kw)
+      file = new(*args, **kw) # do not yield
+      return file unless block_given?
 
-    def initialize(file_path)
-      @file_path = File.expand_path(file_path)
-      @fai = LibHTS.fai_load(file_path)
+      begin
+        yield file
+      ensure
+        file.close
+      end
+      file
+    end
 
-      # IO like API
+    def initialize(file_name)
       if block_given?
-        begin
-          yield self
-        ensure
-          close
-        end
+        message = "HTS::Faidx.new() dose not take block; Please use HTS::Faidx.open() instead"
+        raise message
       end
+
+      @file_name = file_name
+      @fai = LibHTS.fai_load(@file_name)
+
+      raise Errno::ENOENT, "Failed to open #{@file_name}" if @fai.null?
+    end
+
+    def struct
+      @fai
     end
 
     def close
@@ -30,10 +39,10 @@ module HTS
     end
 
     # the number of sequences in the index.
-    def size
+    def length
       LibHTS.faidx_nseq(@fai)
     end
-    alias length size
+    alias size length
 
     # return the length of the requested chromosome.
     def chrom_size(chrom)
@@ -49,10 +58,10 @@ module HTS
     alias chrom_length chrom_size
 
     # FIXME: naming and syntax
-    def cget; end
+    # def cget; end
 
     # FIXME: naming and syntax
-    def get; end
+    # def get; end
 
     # __iter__
   end

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,121 @@
+# frozen_string_literal: true
+
+require_relative "../htslib"
+
+module HTS
+  # A base class for hts files.
+  class Hts
+    class << self
+      private
+
+      def define_getter(name)
+        define_method(name) do
+          check_closed
+          position = tell
+          ary = map(&name)
+          seek(position)
+          ary
+        end
+      end
+
+      def define_iterator(name)
+        define_method("each_#{name}") do |&block|
+          check_closed
+          return to_enum(__method__) unless block
+
+          each do |record|
+            block.call(record.public_send(name))
+          end
+          self
+        end
+      end
+    end
+
+    def initialize(*args)
+      # do nothing
+    end
+
+    def struct
+      @hts_file
+    end
+
+    def to_ptr
+      @hts_file.to_ptr
+    end
+
+    def file_format
+      LibHTS.hts_get_format(@hts_file)[:format].to_s
+    end
+
+    def file_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 set_threads(n)
+      raise TypeError unless n.is_a(Integer)
+
+      if n > 0
+        r = LibHTS.hts_set_threads(@hts_file, n)
+        raise "Failed to set number of threads: #{threads}" if r < 0
+      end
+      self
+    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
+
+    private
+
+    def check_closed
+      raise IOError, "closed stream" if closed?
+    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