htslib 0.1.0 → 0.2.2

data/lib/hts/bcf.rb

@@ -9,10 +9,11 @@ require_relative "bcf/format"
 require_relative "bcf/record"
 
 module HTS
+  # A class for working with VCF, BCF files.
   class Bcf < Hts
     include Enumerable
 
-    attr_reader :file_name, :index_name, :mode, :header
+    attr_reader :file_name, :index_name, :mode, :header, :nthreads
 
     def self.open(*args, **kw)
       file = new(*args, **kw) # do not yield
@@ -26,8 +27,8 @@ module HTS
       file
     end
 
-    def initialize(file_name, mode = "r", index: nil, fai: nil, threads: nil,
-                   create_index: false)
+    def initialize(file_name, mode = "r", index: nil, threads: nil,
+                   build_index: false)
       if block_given?
         message = "HTS::Bcf.new() dose not take block; Please use HTS::Bcf.open() instead"
         raise message
@@ -38,36 +39,39 @@ module HTS
       @file_name  = file_name
       @index_name = index
       @mode       = mode
+      @nthreads   = threads
       @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
+      set_threads(threads) if threads
 
       return if @mode[0] == "w"
 
       @header = Bcf::Header.new(@hts_file)
-
-      create_index(index) if create_index
-
+      build_index(index) if build_index
       @idx = load_index(index)
-
       @start_position = tell
+      super # do nothing
     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)
+    def build_index(index_name = nil, min_shift: 14)
+      check_closed
+
+      if index_name
+        warn "Create index for #{@file_name} to #{index_name}"
       else
-        LibHTS.bcf_index_build(@hts_file, -1)
+        warn "Create index for #{@file_name}"
       end
+      r = LibHTS.bcf_index_build3(@file_name, index_name, min_shift, @nthreads)
+      raise "Failed to build index for #{@file_name}" if r < 0
+
+      self
     end
 
     def load_index(index_name = nil)
+      check_closed
+
       if index_name
         LibHTS.bcf_index_load2(@file_name, index_name)
       else
@@ -76,39 +80,50 @@ module HTS
     end
 
     def index_loaded?
+      check_closed
+
       !@idx.null?
     end
 
     def write_header
-      raise IOError, "closed stream" if closed?
+      check_closed
 
       @header = header.dup
       LibHTS.hts_set_fai_filename(header, @file_name)
-      LibHTS.bcf_hdr_write(@hts_file, header.struct)
+      LibHTS.bcf_hdr_write(@hts_file, header)
     end
 
     def write(var)
-      raise IOError, "closed stream" if closed?
+      check_closed
 
-      var_dup = var.dup = var.dup
+      var_dup = var.dup
       LibHTS.bcf_write(@hts_file, header, var_dup) > 0 || raise
     end
 
     # Close the current file.
 
     def nsamples
+      check_closed
+
       header.nsamples
     end
 
     def samples
+      check_closed
+
       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?
+    def each(copy: false, &block)
+      if copy
+        each_record_copy(&block)
+      else
+        each_record_reuse(&block)
+      end
+    end
+
+    private def each_record_copy
+      check_closed
 
       return to_enum(__method__) unless block_given?
 
@@ -119,11 +134,8 @@ module HTS
       self
     end
 
-    # Iterate over each record.
-    # Record object is reused.
-    # Faster than each_copy.
-    def each
-      raise IOError, "closed stream" if closed?
+    private def each_record_reuse
+      check_closed
 
       return to_enum(__method__) unless block_given?
 
@@ -132,5 +144,146 @@ module HTS
       yield record while LibHTS.bcf_read(@hts_file, header, bcf1) != -1
       self
     end
+
+    def query(...)
+      querys(...) # Fixme
+    end
+
+    # def queryi
+    # end
+
+    def querys(region, copy: false, &block)
+      if copy
+        querys_copy(region, &block)
+      else
+        querys_reuse(region, &block)
+      end
+    end
+
+    # private def queryi_copy
+    # end
+
+    # private def queryi_reuse
+    # end
+
+    private def querys_copy(region)
+      check_closed
+
+      raise "query is only available for BCF files" unless file_format == "bcf"
+      raise "Index file is required to call the query method." unless index_loaded?
+      return to_enum(__method__, region) unless block_given?
+
+      qitr = LibHTS.bcf_itr_querys(@idx, header, region)
+
+      begin
+        loop do
+          bcf1 = LibHTS.bcf_init
+          slen = LibHTS.hts_itr_next(@hts_file[:fp][:bgzf], qitr, bcf1, ::FFI::Pointer::NULL)
+          break if slen == -1
+          raise if slen < -1
+
+          yield Record.new(bcf1, header)
+        end
+      ensure
+        LibHTS.bcf_itr_destroy(qitr)
+      end
+      self
+    end
+
+    private def querys_reuse(region)
+      check_closed
+
+      raise "query is only available for BCF files" unless file_format == "bcf"
+      raise "Index file is required to call the query method." unless index_loaded?
+      return to_enum(__method__, region) unless block_given?
+
+      qitr = LibHTS.bcf_itr_querys(@idx, header, region)
+
+      bcf1 = LibHTS.bcf_init
+      record = Record.new(bcf1, header)
+      begin
+        loop do
+          slen = LibHTS.hts_itr_next(@hts_file[:fp][:bgzf], qitr, bcf1, ::FFI::Pointer::NULL)
+          break if slen == -1
+          raise if slen < -1
+
+          yield record
+        end
+      ensure
+        LibHTS.bcf_itr_destroy(qitr)
+      end
+      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__, key) unless block
+
+      each do |r|
+        yield r.info(key)
+      end
+    end
+
+    def each_format(key)
+      check_closed
+      return to_enum(__method__, key) unless block
+
+      each do |r|
+        yield r.format(key)
+      end
+    end
   end
 end

data/lib/hts/faidx.rb

@@ -6,40 +6,52 @@ module HTS
   class Faidx
     attr_reader :file_name
 
-    class << self
-      alias open new
+    def self.open(*args, **kw)
+      file = new(*args, **kw) # do not yield
+      return file unless block_given?
+
+      begin
+        yield file
+      ensure
+        file.close
+      end
+      file
     end
 
     def initialize(file_name)
+      if block_given?
+        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)
 
-      # IO like API
-      if block_given?
-        begin
-          yield self
-        ensure
-          close
-        end
-      end
+      raise Errno::ENOENT, "Failed to open #{@file_name}" if @fai.null?
+    end
+
+    def struct
+      @fai
     end
 
     def close
       LibHTS.fai_destroy(@fai)
     end
 
+    # FIXME: This doesn't seem to work as expected
+    # def closed?
+    #   @fai.null?
+    # 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)
-      unless chrom.is_a?(String) || chrom.is_a?(Symbol)
-        # FIXME
-        raise ArgumentError, "Expect chrom to be String or Symbol"
-      end
+      raise ArgumentError, "Expect chrom to be String or Symbol" unless chrom.is_a?(String) || chrom.is_a?(Symbol)
 
       chrom = chrom.to_s
       result = LibHTS.faidx_seq_len(@fai, chrom)
@@ -47,12 +59,41 @@ module HTS
     end
     alias chrom_length chrom_size
 
-    # FIXME: naming and syntax
-    def cget; end
+    # return the length of the requested chromosome.
+    def chrom_names
+      Array.new(length) { |i| LibHTS.faidx_iseq(@fai, i) }
+    end
+
+    # @overload fetch(name)
+    #   Fetch the sequence as a String.
+    #   @param name [String] chr1:0-10
+    # @overload fetch(name, start, stop)
+    #   Fetch the sequence as a String.
+    #   @param name [String] the name of the chromosome
+    #   @param start [Integer] the start position of the sequence (0-based)
+    #   @param stop [Integer] the end position of the sequence (0-based)
+    #   @return [String] the sequence
+
+    def seq(name, start = nil, stop = nil)
+      name = name.to_s
+      rlen = FFI::MemoryPointer.new(:int)
 
-    # FIXME: naming and syntax
-    def get; end
+      if start.nil? && stop.nil?
+        result = LibHTS.fai_fetch(@fai, name, rlen)
+      else
+        start < 0    && raise(ArgumentError, "Expect start to be >= 0")
+        stop  < 0    && raise(ArgumentError, "Expect stop to be >= 0")
+        start > stop && raise(ArgumentError, "Expect start to be <= stop")
 
-    # __iter__
+        result = LibHTS.faidx_fetch_seq(@fai, name, start, stop, rlen)
+      end
+
+      case rlen.read_int
+      when -2 then raise "Invalid chromosome name: #{name}"
+      when -1 then raise "Error fetching sequence: #{name}:#{start}-#{stop}"
+      end
+
+      result
+    end
   end
 end

data/lib/hts/hts.rb

@@ -3,7 +3,38 @@
 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
@@ -12,11 +43,11 @@ module HTS
       @hts_file.to_ptr
     end
 
-    def format
+    def file_format
       LibHTS.hts_get_format(@hts_file)[:format].to_s
     end
 
-    def format_version
+    def file_format_version
       v = LibHTS.hts_get_format(@hts_file)[:version]
       major = v[:major]
       minor = v[:minor]
@@ -38,6 +69,21 @@ module HTS
       @hts_file.nil? || @hts_file.null?
     end
 
+    def set_threads(n = nil)
+      if n.nil?
+        require "etc"
+        n = [Etc.nprocessors - 1, 1].max
+      end
+      raise TypeError unless n.is_a?(Integer)
+      raise ArgumentError, "Number of threads must be positive" if n < 1
+
+      r = LibHTS.hts_set_threads(@hts_file, n)
+      raise "Failed to set number of threads: #{threads}" if r < 0
+
+      @nthreads = n
+      self
+    end
+
     def seek(offset)
       if @hts_file[:is_cram] == 1
         LibHTS.cram_seek(@hts_file[:fp][:cram], offset, IO::SEEK_SET)
@@ -70,5 +116,11 @@ module HTS
         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,
-      [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,
-      [HFILE, :pointer, :size_t],
+      [HFile, :pointer, :size_t],
       :ssize_t
 
     # Write _length_ bytes from _data_ to the file. If no I/O errors occur,
@@ -181,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
@@ -193,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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module HTS
+  # Module for working with C HTSlib.
   module LibHTS
     typedef :int64, :hts_pos_t
     typedef :pointer, :bam_plp_auto_f
@@ -24,9 +25,9 @@ module HTS
         :f,              :pointer # kstream_t
     end
 
-    # HFILE
+    # HFile
 
-    class HFILE < FFI::BitStruct
+    class HFile < FFI::BitStruct
       layout \
         :buffer,        :string,
         :begin,         :string,
@@ -56,7 +57,7 @@ module HTS
         :uncompressed_block,     :pointer,
         :compressed_block,       :pointer,
         :cache,                  :pointer,
-        :fp,                     HFILE.ptr,
+        :fp,                     HFile.ptr,
         :mt,                     :pointer,
         :idx,                    :pointer,
         :idx_build_otf,          :int,
@@ -189,6 +190,16 @@ module HTS
         )
     end
 
+    class HtsReglist < FFI::Struct
+      layout \
+        :reg,            :string,
+        :intervals,      :pointer, # hts_pair_pos_t
+        :tid,            :int,
+        :count,          :uint32_t,
+        :min_beg,        :hts_pos_t,
+        :max_end,        :hts_pos_t
+    end
+
     # HtsFile
     class SamHdr < FFI::Struct
       layout \
@@ -217,7 +228,7 @@ module HTS
         union_layout(
           :bgzf,         BGZF.ptr,
           :cram,         :pointer, # cram_fd
-          :hfile,        HFILE.ptr
+          :hfile,        HFile.ptr
         ),
         :state,          :pointer,
         :format,         HtsFormat,
@@ -263,7 +274,7 @@ module HTS
         :n_reg,          :int,
         :beg,            :int64,
         :end,            :int64,
-        :reg_list,       :pointer,
+        :reg_list,       :pointer, # HtsReglist.ptr,
         :curr_tid,       :int,
         :curr_reg,       :int,
         :curr_intv,      :int,
@@ -392,6 +403,7 @@ module HTS
         :n,              :int
     end
 
+    # Complete textual representation of a header line
     class BcfHrec < FFI::Struct
       layout \
         :type,           :int,
@@ -402,21 +414,6 @@ module HTS
         :vals,           :pointer
     end
 
-    class BcfFmt < FFI::BitStruct
-      layout \
-        :id,             :int,
-        :n,              :int,
-        :size,           :int,
-        :type,           :int,
-        :p,              :pointer, # uint8_t
-        :p_len,          :uint32,
-        :_p_off_free,    :uint32 # bit_fields
-
-      bit_fields :_p_off_free,
-                 :p_off,  31,
-                 :p_free, 1
-    end
-
     class BcfInfo < FFI::BitStruct
       layout \
         :key,            :int,
@@ -466,6 +463,21 @@ module HTS
         :m,              [:int, 3]
     end
 
+    class BcfFmt < FFI::BitStruct
+      layout \
+        :id,             :int,
+        :n,              :int,
+        :size,           :int,
+        :type,           :int,
+        :p,              :pointer, # uint8_t
+        :p_len,          :uint32,
+        :_p_off_free,    :uint32 # bit_fields
+
+      bit_fields :_p_off_free,
+                 :p_off,  31,
+                 :p_free, 1
+    end
+
     class BcfDec < FFI::Struct
       layout \
         :m_fmt,          :int,
@@ -516,5 +528,15 @@ module HTS
         LibHTS.bcf_destroy(ptr) unless ptr.null?
       end
     end
+
+    CramContentType = enum(
+      :ct_error,           -1,
+      :file_header,        0,
+      :compression_header, 1,
+      :mapped_slice,       2,
+      :unmapped_slice,     3, # cram v1.0 only
+      :external,           4,
+      :core,               5
+    )
   end
 end