htslib 0.0.10 → 0.2.1

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"
@@ -12,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_path, :mode, :header
+    attr_reader :file_name, :index_name, :mode, :header
 
     def self.open(*args, **kw)
       file = new(*args, **kw) # do not yield
@@ -29,7 +27,7 @@ module HTS
       file
     end
 
-    def initialize(file_name, mode = "r", index: nil, fai: nil, threads: nil,
+    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"
@@ -38,55 +36,91 @@ 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?
 
-      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
+      @idx = load_index(index)
+      @start_position = tell
+      super # do nothing
+    end
+
+    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 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_name)
-      LibHTS.bcf_hdr_write(@hts_file, header.struct)
+      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?
-    end
 
     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
+    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?
 
       while LibHTS.bcf_read(@hts_file, header, bcf1 = LibHTS.bcf_init) != -1
@@ -96,10 +130,9 @@ module HTS
       self
     end
 
-    # Iterate over each record.
-    # Record object is reused.
-    # Faster than each_copy.
-    def each
+    private def each_record_reuse
+      check_closed
+
       return to_enum(__method__) unless block_given?
 
       bcf1 = LibHTS.bcf_init
@@ -107,5 +140,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

@@ -1,48 +1,57 @@
 # 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_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)
@@ -50,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/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,7 +1,40 @@
+# 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
@@ -10,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]
@@ -24,7 +57,28 @@ 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 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)
@@ -48,9 +102,20 @@ 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
+
+    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