htslib 0.2.3 → 0.2.6

data/lib/hts/bcf/header.rb

@@ -1,11 +1,24 @@
 # frozen_string_literal: true
 
+require_relative "header_record"
+
 module HTS
   class Bcf < Hts
     # A class for working with VCF records.
+    # NOTE: This class has a lot of methods that are not stable.
+    # The method names and the number of arguments may change in the future.
     class Header
-      def initialize(hts_file)
-        @bcf_hdr = LibHTS.bcf_hdr_read(hts_file)
+      def initialize(arg = nil)
+        case arg
+        when LibHTS::HtsFile
+          @bcf_hdr = LibHTS.bcf_hdr_read(arg)
+        when LibHTS::BcfHdr
+          @bcf_hdr = arg
+        when nil
+          @bcf_hdr = LibHTS.bcf_hdr_init("w")
+        else
+          raise TypeError, "Invalid argument"
+        end
       end
 
       def struct
@@ -20,6 +33,10 @@ module HTS
         LibHTS.bcf_hdr_get_version(@bcf_hdr)
       end
 
+      def set_version(version)
+        LibHTS.bcf_hdr_set_version(@bcf_hdr, version)
+      end
+
       def nsamples
         LibHTS.bcf_hdr_nsamples(@bcf_hdr)
       end
@@ -31,6 +48,45 @@ module HTS
           .map(&:read_string)
       end
 
+      def add_sample(sample, sync: true)
+        LibHTS.bcf_hdr_add_sample(@bcf_hdr, sample)
+        self.sync if sync
+      end
+
+      def merge(hdr)
+        LibHTS.bcf_hdr_merge(@bcf_hdr, hdr.struct)
+      end
+
+      def sync
+        LibHTS.bcf_hdr_sync(@bcf_hdr)
+      end
+
+      def read_bcf(fname)
+        LibHTS.bcf_hdr_set(@bcf_hdr, fname)
+      end
+
+      def append(line)
+        LibHTS.bcf_hdr_append(@bcf_hdr, line)
+      end
+
+      def delete(bcf_hl_type, key) # FIXME
+        type = bcf_hl_type_to_int(bcf_hl_type)
+        LibHTS.bcf_hdr_remove(@bcf_hdr, type, key)
+      end
+
+      def get_hrec(bcf_hl_type, key, value, str_class = nil)
+        type = bcf_hl_type_to_int(bcf_hl_type)
+        hrec = LibHTS.bcf_hdr_get_hrec(@bcf_hdr, type, key, value, str_class)
+        HeaderRecord.new(hrec)
+      end
+
+      def seqnames
+        n = FFI::MemoryPointer.new(:int)
+        names = LibHTS.bcf_hdr_seqnames(@bcf_hdr, n)
+        names.read_array_of_pointer(n.read_int)
+             .map(&:read_string)
+      end
+
       def to_s
         kstr = LibHTS::KString.new
         raise "Failed to get header string" unless LibHTS.bcf_hdr_format(@bcf_hdr, 0, kstr)
@@ -40,6 +96,27 @@ module HTS
 
       private
 
+      def bcf_hl_type_to_int(bcf_hl_type)
+        return bcf_hl_type if bcf_hl_type.is_a?(Integer)
+
+        case bcf_hl_type.to_s.upcase
+        when "FILTER", "FIL"
+          LibHTS::BCF_HL_FLT
+        when "INFO"
+          LibHTS::BCF_HL_INFO
+        when "FORMAT", "FMT"
+          LibHTS::BCF_HL_FMT
+        when "CONTIG", "CTG"
+          LibHTS::BCF_HL_CTG
+        when "STRUCTURED", "STR"
+          LibHTS::BCF_HL_STR
+        when "GENOTYPE", "GEN"
+          LibHTS::BCF_HL_GEN
+        else
+          raise TypeError, "Invalid argument"
+        end
+      end
+
       def initialize_copy(orig)
         @bcf_hdr = LibHTS.bcf_hdr_dup(orig.struct)
       end

data/lib/hts/bcf/header_record.rb

@@ -3,9 +3,43 @@
 module HTS
   class Bcf < Hts
     class HeaderRecord
-      def initialize
+      def initialize(arg = nil)
+        case arg
+        when LibHTS::BcfHrec
+          @bcf_hrec = arg
+        else
+          raise TypeError, "Invalid argument"
+        end
+      end
+
+      def struct
         @bcf_hrec
       end
+
+      def add_key(key)
+        LibHTS.bcf_hrec_add_key(@bcf_hrec, key, key.length)
+      end
+
+      def set_value(i, val, quote: true)
+        is_quoted = quote ? 1 : 0
+        LibHTS.bcf_hrec_set_val(@bcf_hrec, i, val, val.length, is_quoted)
+      end
+
+      def find_key(key)
+        LibHTS.bcf_hrec_find_key(@bcf_hrec, key)
+      end
+
+      def to_s
+        kstr = LibHTS::KString.new
+        LibHTS.bcf_hrec_format(@bcf_hrec, kstr)
+        kstr[:s]
+      end
+
+      private
+
+      def initialize_copy(orig)
+        @bcf_hrec = LibHTS.bcf_hrec_dup(orig.struct)
+      end
     end
   end
 end

data/lib/hts/bcf/info.rb

@@ -9,31 +9,11 @@ module HTS
         @p1 = FFI::MemoryPointer.new(:pointer) # FIXME: naming
       end
 
-      # For compatibility with htslib.cr.
-      def get_int(key)
-        get(key, :int)
-      end
-
-      # For compatibility with htslib.cr.
-      def get_float(key)
-        get(key, :float)
-      end
-
-      # For compatibility with htslib.cr.
-      def get_string(key)
-        get(key, :string)
-      end
-
-      # For compatibility with htslib.cr.
-      def get_flag(key)
-        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.
+      # @note: Why is this method named "get" instead of "fetch"?
+      # This is for compatibility with the Crystal language
+      # which provides methods like `get_int`, `get_float`, etc.
+      # I think they are better than `fetch_int`` and `fetch_float`.
       def get(key, type = nil)
         n = FFI::MemoryPointer.new(:int)
         p1 = @p1
@@ -70,6 +50,30 @@ module HTS
         end
       end
 
+      # For compatibility with HTS.cr.
+      def get_int(key)
+        get(key, :int)
+      end
+
+      # For compatibility with HTS.cr.
+      def get_float(key)
+        get(key, :float)
+      end
+
+      # For compatibility with HTS.cr.
+      def get_string(key)
+        get(key, :string)
+      end
+
+      # For compatibility with HTS.cr.
+      def get_flag(key)
+        get(key, :flag)
+      end
+
+      def [](key)
+        get(key)
+      end
+
       # FIXME: naming? room for improvement.
       def fields
         keys.map do |key|

data/lib/hts/bcf.rb

@@ -52,10 +52,9 @@ module HTS
       build_index(index) if build_index
       @idx = load_index(index)
       @start_position = tell
-      super # do nothing
     end
 
-    def build_index(index_name = nil, min_shift: 14)
+    def build_index(index_name = nil, min_shift: 14, threads: 2)
       check_closed
 
       if index_name
@@ -63,10 +62,15 @@ module HTS
       else
         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
+      case LibHTS.bcf_index_build3(@file_name, index_name, min_shift, (@nthreads || threads))
+      when 0 # sccessful
+      when -1 then raise "indexing failed"
+      when -2 then raise "opening #{@file_name} failed"
+      when -3 then raise "format not indexable"
+      when -4 then raise "failed to create and/or save the index"
+      else raise "unknown error"
+      end
+      self # for method chaining
     end
 
     def load_index(index_name = nil)
@@ -85,22 +89,34 @@ module HTS
       !@idx.null?
     end
 
-    def write_header
+    def close
+      LibHTS.hts_idx_destroy(@idx) unless @idx&.null?
+      @idx = nil
+      super
+    end
+
+    def write_header(header)
       check_closed
 
       @header = header.dup
-      LibHTS.hts_set_fai_filename(header, @file_name)
       LibHTS.bcf_hdr_write(@hts_file, header)
     end
 
-    def write(var)
+    def header=(header)
+      write_header(header)
+    end
+
+    def write(record)
       check_closed
 
-      var_dup = var.dup
-      LibHTS.bcf_write(@hts_file, header, var_dup) > 0 || raise
+      # record = record.dup
+      r = LibHTS.bcf_write(@hts_file, header, record)
+      raise "Failed to write record" if r < 0
     end
 
-    # Close the current file.
+    def <<(var)
+      write(var)
+    end
 
     def nsamples
       check_closed
@@ -122,29 +138,6 @@ module HTS
       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
-        record = Record.new(bcf1, header)
-        yield record
-      end
-      self
-    end
-
-    private def each_record_reuse
-      check_closed
-
-      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
-
     def query(...)
       querys(...) # Fixme
     end
@@ -166,55 +159,6 @@ module HTS
     # 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
@@ -231,13 +175,13 @@ module HTS
     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
+      raise NotImplementedError unless key
+
+      ary = map { |r| r.info(key) }
+
+      # ary = each_copy.map { |r| r.info }
+      # ary = map { |r| r.info.clone }
+
       seek(position)
       ary
     end
@@ -245,13 +189,13 @@ module HTS
     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
+      raise NotImplementedError unless key
+
+      ary = map { |r| r.format(key) }
+
+      # ary = each_copy.map { |r| r.format }
+      # ary = map { |r| r.format.clone }
+
       seek(position)
       ary
     end
@@ -285,5 +229,81 @@ module HTS
         yield r.format(key)
       end
     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?
+
+      qiter = LibHTS.bcf_itr_querys(@idx, header, region)
+      raise "Failed to query region #{region}" if qiter.null?
+
+      bcf1 = LibHTS.bcf_init
+      record = Record.new(bcf1, header)
+      begin
+        loop do
+          slen = LibHTS.hts_itr_next(@hts_file[:fp][:bgzf], qiter, bcf1, ::FFI::Pointer::NULL)
+          break if slen == -1
+          raise if slen < -1
+
+          yield record
+        end
+      ensure
+        LibHTS.bcf_itr_destroy(qiter)
+      end
+      self
+    end
+
+    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?
+
+      qiter = LibHTS.bcf_itr_querys(@idx, header, region)
+      raise "Failed to query region #{region}" if qiter.null?
+
+      begin
+        loop do
+          bcf1 = LibHTS.bcf_init
+          slen = LibHTS.hts_itr_next(@hts_file[:fp][:bgzf], qiter, bcf1, ::FFI::Pointer::NULL)
+          break if slen == -1
+          raise if slen < -1
+
+          yield Record.new(bcf1, header)
+        end
+      ensure
+        LibHTS.bcf_itr_destroy(qiter)
+      end
+      self
+    end
+
+    def each_record_reuse
+      check_closed
+
+      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
+
+    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
+        record = Record.new(bcf1, header)
+        yield record
+      end
+      self
+    end
   end
 end

data/lib/hts/faidx/sequence.rb

@@ -0,0 +1,64 @@
+require_relative "../faidx"
+
+module HTS
+  class Faidx
+    class Sequence
+      attr_reader :name, :faidx
+
+      def initialize(faidx, name)
+        raise unless faidx.has_key?(name)
+
+        @faidx = faidx
+        @name = name
+      end
+
+      def length
+        faidx.seq_len(name)
+      end
+      alias size length
+
+      def seq(start = nil, stop = nil)
+        faidx.seq(name, start, stop)
+      end
+
+      def qual(start = nil, stop = nil)
+        faidx.qual(name, start, stop)
+      end
+
+      def [](arg)
+        case arg
+        when Integer
+          if arg >= 0
+            start = arg
+            stop = arg
+          else
+            start = length + arg
+            stop = length + arg
+          end
+        when Range
+          arg = Range.new(arg.begin, arg.end + length, arg.exclude_end?) if arg.end&.<(0)
+          arg = Range.new(arg.begin + length, arg.end, arg.exclude_end?) if arg.begin&.<(0)
+          if arg.begin.nil?
+            if arg.end.nil?
+              start = nil
+              stop = nil
+            else
+              start = 0
+              stop = arg.exclude_end? ? arg.end - 1 : arg.end
+            end
+          elsif arg.end.nil?
+            # always include the first base
+            start = arg.begin
+            stop = length - 1
+          else
+            start = arg.begin
+            stop = arg.exclude_end? ? arg.end - 1 : arg.end
+          end
+        else
+          raise ArgumentError
+        end
+        seq(start, stop)
+      end
+    end
+  end
+end

data/lib/hts/faidx.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../htslib"
+require_relative "faidx/sequence"
 
 module HTS
   class Faidx
@@ -25,7 +26,11 @@ module HTS
       end
 
       @file_name = file_name
-      @fai = LibHTS.fai_load(@file_name)
+      @fai = if [".fq", ".fastq"].include? File.extname(@file_name)
+               LibHTS.fai_load_format(@file_name, 2)
+             else
+               LibHTS.fai_load(@file_name)
+             end
 
       raise Errno::ENOENT, "Failed to open #{@file_name}" if @fai.null?
     end
@@ -38,10 +43,9 @@ module HTS
       LibHTS.fai_destroy(@fai)
     end
 
-    # FIXME: This doesn't seem to work as expected
-    # def closed?
-    #   @fai.null?
-    # end
+    def file_format
+      @fai[:format]
+    end
 
     # the number of sequences in the index.
     def length
@@ -50,31 +54,48 @@ module HTS
     alias size length
 
     # return the length of the requested chromosome.
-    def chrom_size(chrom)
+    def names
+      Array.new(length) { |i| LibHTS.faidx_iseq(@fai, i) }
+    end
+
+    alias keys names
+
+    def has_key?(key)
+      raise ArgumentError, "Expect chrom to be String or Symbol" unless key.is_a?(String) || key.is_a?(Symbol)
+
+      key = key.to_s
+      case LibHTS.faidx_has_seq(@fai, key)
+      when 1 then true
+      when 0 then false
+      else raise
+      end
+    end
+
+    def [](name)
+      name = LibHTS.faidx_iseq(@fai, name) if name.is_a?(Integer)
+      Sequence.new(self, name)
+    end
+
+    # return the length of the requested chromosome.
+    def seq_len(chrom)
       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)
       result == -1 ? nil : result
     end
-    alias chrom_length chrom_size
 
-    # return the length of the requested chromosome.
-    def chrom_names
-      Array.new(length) { |i| LibHTS.faidx_iseq(@fai, i) }
-    end
-
-    # @overload fetch(name)
+    # @overload seq(name)
     #   Fetch the sequence as a String.
     #   @param name [String] chr1:0-10
-    # @overload fetch(name, start, stop)
+    # @overload seq(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)
+    def fetch_seq(name, start = nil, stop = nil)
       name = name.to_s
       rlen = FFI::MemoryPointer.new(:int)
 
@@ -84,6 +105,7 @@ module HTS
         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")
+        stop >= seq_len(name) && raise(ArgumentError, "Expect stop to be < seq_len")
 
         result = LibHTS.faidx_fetch_seq(@fai, name, start, stop, rlen)
       end
@@ -95,5 +117,32 @@ module HTS
 
       result
     end
+
+    alias seq fetch_seq
+
+    def fetch_qual(name, start = nil, stop = nil)
+      name = name.to_s
+      rlen = FFI::MemoryPointer.new(:int)
+
+      if start.nil? && stop.nil?
+        result = LibHTS.fai_fetchqual(@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")
+        stop >= seq_len(name) && raise(ArgumentError, "Expect stop to be < seq_len")
+
+        result = LibHTS.faidx_fetch_qual(@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
+
+    alias qual fetch_qual
   end
 end