htslib 0.2.5 → 0.2.8

data/lib/hts/bcf/header.rb

@@ -94,6 +94,14 @@ module HTS
         kstr[:s]
       end
 
+      def name2id(name)
+        LibHTS.bcf_hdr_name2id(@bcf_hdr, name)
+      end
+
+      def id2name(id)
+        LibHTS.bcf_hdr_id2name(@bcf_hdr, id)
+      end
+
       private
 
       def bcf_hl_type_to_int(bcf_hl_type)

data/lib/hts/bcf/info.rb

@@ -9,31 +9,11 @@ module HTS
         @p1 = FFI::MemoryPointer.new(:pointer) # FIXME: naming
       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
-
       # @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/record.rb

@@ -4,8 +4,8 @@ module HTS
   class Bcf < Hts
     # A class for working with VCF records.
     class Record
-      def initialize(bcf_t, header)
-        @bcf1 = bcf_t
+      def initialize(header, bcf_t = nil)
+        @bcf1 = bcf_t || LibHTS.bcf_init
         @header = header
       end
 

data/lib/hts/bcf.rb

@@ -54,7 +54,7 @@ module HTS
       @start_position = tell
     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
@@ -62,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 # successful
+      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)
@@ -93,19 +98,25 @@ module HTS
     def write_header(header)
       check_closed
 
-      @header = header.dup
+      @header = header.clone
       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
-      r = LibHTS.bcf_write(@hts_file, header, var_dup)
+      # 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
@@ -119,35 +130,6 @@ module HTS
       header.samples
     end
 
-    def each(copy: false, &block)
-      if copy
-        each_record_copy(&block)
-      else
-        each_record_reuse(&block)
-      end
-    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
-
     # @!macro [attach] define_getter
     #   @method $1
     #   Get $1 array
@@ -164,13 +146,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
@@ -178,13 +160,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
@@ -219,20 +201,71 @@ module HTS
       end
     end
 
-    private
+    def each(copy: false, &block)
+      if copy
+        each_record_copy(&block)
+      else
+        each_record_reuse(&block)
+      end
+    end
 
-    def querys_reuse(region)
+    def query(region, beg = nil, end_ = nil, copy: false, &block)
       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?
+
+      if beg && end_
+        tid = header.name2id(region)
+        queryi(tid, beg, end_, copy:, &block)
+      elsif beg.nil? && end_.nil?
+        querys(region, copy:, &block)
+      else
+        raise ArgumentError, "beg and end must be specified together"
+      end
+    end
+
+    private
+
+    def queryi(tid, beg, end_, copy: false, &block)
+      if copy
+        queryi_copy(tid, beg, end_, &block)
+      else
+        queryi_reuse(tid, beg, end_, &block)
+      end
+    end
+
+    def querys(region, copy: false, &block)
+      if copy
+        querys_copy(region, &block)
+      else
+        querys_reuse(region, &block)
+      end
+    end
+
+    def queryi_reuse(tid, beg, end_, &block)
+      return to_enum(__method__, tid, beg, end_) unless block_given?
+
+      qiter = LibHTS.bcf_itr_queryi(@idx, tid, beg, end_)
+      raise "Failed to query region #{tid} #{beg} #{end_}" if qiter.null?
+
+      query_reuse_yield(qiter, &block)
+      self
+    end
+
+    def querys_reuse(region, &block)
       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?
 
+      query_reuse_yield(qiter, &block)
+      self
+    end
+
+    def query_reuse_yield(qiter)
       bcf1 = LibHTS.bcf_init
-      record = Record.new(bcf1, header)
+      record = Record.new(header, bcf1)
       begin
         loop do
           slen = LibHTS.hts_itr_next(@hts_file[:fp][:bgzf], qiter, bcf1, ::FFI::Pointer::NULL)
@@ -244,32 +277,39 @@ module HTS
       ensure
         LibHTS.bcf_itr_destroy(qiter)
       end
-      self
     end
 
-    def querys_copy(region)
-      check_closed
+    def queryi_copy(tid, beg, end_, &block)
+      return to_enum(__method__, tid, beg, end_) unless block_given?
 
-      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?
+      qiter = LibHTS.bcf_itr_queryi(@idx, tid, beg, end_)
+      raise "Failed to query region #{tid} #{beg} #{end_}" if qiter.null?
+
+      query_copy_yield(qiter, &block)
+      self
+    end
+
+    def querys_copy(region, &block)
       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
+      query_copy_yield(qiter, &block)
+      self
+    end
 
-          yield Record.new(bcf1, header)
-        end
-      ensure
-        LibHTS.bcf_itr_destroy(qiter)
+    def query_copy_yield(qiter)
+      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(header, bcf1)
       end
-      self
+    ensure
+      LibHTS.bcf_itr_destroy(qiter)
     end
 
     def each_record_reuse
@@ -278,7 +318,7 @@ module HTS
       return to_enum(__method__) unless block_given?
 
       bcf1 = LibHTS.bcf_init
-      record = Record.new(bcf1, header)
+      record = Record.new(header, bcf1)
       yield record while LibHTS.bcf_read(@hts_file, header, bcf1) != -1
       self
     end
@@ -289,7 +329,7 @@ module HTS
       return to_enum(__method__) unless block_given?
 
       while LibHTS.bcf_read(@hts_file, header, bcf1 = LibHTS.bcf_init) != -1
-        record = Record.new(bcf1, header)
+        record = Record.new(header, bcf1)
         yield record
       end
       self

data/lib/hts/faidx/sequence.rb

@@ -0,0 +1,62 @@
+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,12 @@ module HTS
       end
 
       @file_name = file_name
-      @fai = LibHTS.fai_load(@file_name)
+      @fai = case File.extname(@file_name)
+             when ".fq", ".fastq"
+               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
@@ -35,13 +41,19 @@ module HTS
     end
 
     def close
+      return if closed?
+
       LibHTS.fai_destroy(@fai)
+      @fai = nil
     end
 
-    # FIXME: This doesn't seem to work as expected
-    # def closed?
-    #   @fai.null?
-    # end
+    def closed?
+      @fai.nil? || @fai.null?
+    end
+
+    def file_format
+      @fai[:format]
+    end
 
     # the number of sequences in the index.
     def length
@@ -50,42 +62,85 @@ 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)
+
+      if start.nil? && stop.nil?
+        result = LibHTS.fai_fetch64(@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_seq64(@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 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_fetch(@fai, name, rlen)
+        result = LibHTS.fai_fetchqual64(@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_seq(@fai, name, start, stop, rlen)
+        result = LibHTS.faidx_fetch_qual64(@fai, name, start, stop, rlen)
       end
 
       case rlen.read_int
@@ -95,5 +150,7 @@ module HTS
 
       result
     end
+
+    alias qual fetch_qual
   end
 end

data/lib/hts/hts.rb

@@ -69,6 +69,11 @@ module HTS
       @hts_file.nil? || @hts_file.null?
     end
 
+    def fai=(fai)
+      check_closed
+      LibHTS.hts_set_fai_filename(@hts_file, fai) > 0 || raise
+    end
+
     def set_threads(n = nil)
       if n.nil?
         require "etc"
@@ -107,14 +112,12 @@ module HTS
     end
 
     def rewind
-      if @start_position
-        r = seek(@start_position)
-        raise "Failed to rewind: #{r}" if r < 0
+      raise "Cannot rewind: no start position" unless @start_position
 
-        tell
-      else
-        raise "Cannot rewind: no start position"
-      end
+      r = seek(@start_position)
+      raise "Failed to rewind: #{r}" if r < 0
+
+      tell
     end
 
     private

data/lib/hts/libhts/bgzf.rb

@@ -41,7 +41,7 @@ module HTS
       :ssize_t
 
     # Write _length_ bytes from _data_ to the file, the index will be used to
-    # decide the amount of uncompressed data to be writen to each bgzip block.
+    # decide the amount of uncompressed data to be written to each bgzip block.
     attach_function \
       :bgzf_block_write,
       [BGZF, :pointer, :size_t],