htslib 0.0.8 → 0.0.10

data/lib/hts/hts.rb

@@ -0,0 +1,56 @@
+require_relative "../htslib"
+
+module HTS
+  class Hts
+    def struct
+      @hts_file
+    end
+
+    def to_ptr
+      @hts_file.to_ptr
+    end
+
+    def format
+      LibHTS.hts_get_format(@hts_file)[:format].to_s
+    end
+
+    def 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 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
+      r = seek(@start_position) if @start_position
+      raise "Failed to rewind: #{r}" if r < 0
+      r 
+    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

data/lib/hts/libhts/constants.rb

@@ -2,7 +2,6 @@
 
 module HTS
   module LibHTS
-    typedef :pointer, :HFILE
     typedef :int64, :hts_pos_t
     typedef :pointer, :bam_plp_auto_f
 
@@ -25,6 +24,25 @@ module HTS
         :f,              :pointer # kstream_t
     end
 
+    # HFILE
+
+    class HFILE < FFI::BitStruct
+      layout \
+        :buffer,        :string,
+        :begin,         :string,
+        :end,           :string,
+        :limit,         :string,
+        :backend,       :pointer,
+        :offset,        :size_t,
+        :_flags,        :uint,
+        :has_errno,     :int
+      
+      bit_fields :_flags,
+                 :at_eof,     1,
+                 :mobile,     1,
+                 :readonly,   1
+    end
+
     # BGZF
     class BGZF < FFI::BitStruct
       layout \
@@ -38,7 +56,7 @@ module HTS
         :uncompressed_block,     :pointer,
         :compressed_block,       :pointer,
         :cache,                  :pointer,
-        :fp,                     :HFILE,
+        :fp,                     HFILE.ptr,
         :mt,                     :pointer,
         :idx,                    :pointer,
         :idx_build_otf,          :int,
@@ -198,8 +216,8 @@ module HTS
         :fp,
         union_layout(
           :bgzf,         BGZF.ptr,
-          :cram,         :pointer,
-          :hfile,        :pointer # HFILE
+          :cram,         :pointer, # cram_fd
+          :hfile,        HFILE.ptr
         ),
         :state,          :pointer,
         :format,         HtsFormat,

data/lib/hts/libhts/cram.rb

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+
+module HTS
+  module LibHTS
+
+=begin
+
+attach_function \
+  :cram_fd_get_header,
+  [CramFd],
+  SamHdr.by_ref
+
+attach_function \
+  :cram_fd_set_header,
+  [CramFd, SamHdr.by_ref],
+  :void
+  
+attach_function \
+  :cram_fd_get_version,
+  [CramFd],
+  :int
+
+attach_function \
+  :cram_fd_set_version,
+  [CramFd, :int],
+  :void
+
+attach_function \
+  :cram_major_vers,
+  [CramFd],
+  :int
+
+attach_function \
+  :cram_minor_vers,
+  [CramFd],
+  :int
+
+attach_function \
+  :cram_fd_get_fp,
+  [CramFd],
+  HFile.by_ref
+
+attach_function \
+  :cram_fd_set_fp,
+  [CramFd, HFile],
+  :void
+
+attach_function \
+  :cram_container_get_length,
+  [CramContainer],
+  :int32
+
+attach_function \
+  :cram_container_set_length,
+  [CramContainer, :int32],
+  :void
+
+attach_function \
+  :cram_container_get_num_blocks,
+  [CramContainer],
+  :int32
+
+attach_function \
+  :cram_container_set_num_blocks,
+  [CramContainer, :int32],
+  :void
+  
+attach_function \
+  :cram_container_get_landmarks,
+  [CramContainer, :int32],
+  :pointer
+
+attach_function \
+  :cram_container_set_landmarks,
+  [CramContainer, :Int32, :pointer],
+  :void
+
+attach_function \
+  :cram_container_is_empty,
+  [CramFd],
+  :int
+
+attach_function \
+  :cram_block_get_content_id,
+  [CramBlock],
+  :int32
+
+attach_function \
+  :cram_block_get_comp_size,
+  [CramBlock],
+  :int32
+
+attach_function \
+  :cram_block_get_uncomp_size,
+  [CramBlock],
+  :int32
+
+attach_function \
+  :cram_block_get_crc32,
+  [CramBlock],
+  :int32
+
+attach_function \
+  :cram_block_get_data,
+  [CramBlock],
+  :pointer
+
+attach_function \
+  :cram_block_get_content_type,
+  [CramBlock],
+  CramContentType                # ?
+
+attach_function \
+  :cram_block_set_content_id,
+  [CramBlock, :int32],
+  :void
+  
+attach_function \
+  :cram_block_set_comp_size,
+  [CramBlock, :int32],
+  :void
+
+attach_function \
+  :cram_block_set_uncomp_size,
+  [CramBlock, :int32],
+  :void
+  
+attach_function \
+  :cram_block_set_crc32,
+  [CramBlock, :int32],
+  :void
+
+attach_function \
+  :cram_block_set_data,
+  [CramBlock, :pointer],
+  :void
+
+attach_function \
+  :cram_block_append,
+  [CramBlock, :pointer, :int],
+  :int
+
+attach_function \
+  :cram_block_update_size,
+  [CramBlock],
+  :void
+
+attach_function \
+  :cram_block_get_offset,
+  [CramBlock],
+  :size_t
+
+attach_function \
+  :cram_block_set_offset,
+  [CramBlock, :size_t],
+  :void
+
+attach_function \
+  :cram_block_size,
+  [CramBlock],
+  :uint32
+
+attach_function \
+  :cram_transcode_rg,
+  [CramFd, CramFd, CramContainer, :int, :pointer, :pointer],
+  :int
+
+attach_function \
+  :cram_copy_slice,
+  [CramFd, CramFd, :int32],
+  :int
+
+attach_function \
+  :cram_new_block,
+  [CramContentType, :int],
+  CramBlock
+
+attach_function \
+  :cram_read_block,
+  [CramFd],
+  CramBlock
+
+attach_function \
+  :cram_write_block,
+  [CramFd, CramBlock],
+  :int
+
+attach_function \
+  :cram_free_block,
+  [CramBlock],
+  :void
+  
+attach_function \
+  :cram_uncompress_block,
+  [CramBlock],
+  :int
+
+attach_function \
+  :cram_compress_block,
+  [CramFd, CramBlock, CramMetrics, :int, :int],
+  :int
+
+attach_function \
+  :cram_compress_block2,
+  [CramFd, CramSlice, CramBlock, CramMetrics, :int, :int],
+  :int
+
+attach_function \
+  :cram_new_container,
+  [:int, :int],
+  CramContainer
+
+attach_function \
+  :cram_free_container,
+  [CramContainer],
+  :void
+
+attach_function \
+  :cram_read_container,
+  [CramFd],
+  CramContainer
+
+attach_function \
+  :cram_write_container,
+  [CramFd, CramContainer],
+  :int
+
+attach_function \
+  :cram_store_container,
+  [CramFd, CramContainer, :string, :pointer],
+  :int
+
+attach_function \
+  :cram_container_size,
+  [CramContainer],
+  :int
+
+attach_function \
+  :cram_open,
+  [:string, :string],
+  CramFd
+
+attach_function \
+  :cram_dopen,
+  [:pointer, :string, :string],
+  CramFd
+
+attach_function \
+  :cram_close,
+  [CramFd],
+  :int
+
+=end
+
+attach_function \
+  :cram_seek,
+  [:pointer, :off_t, :int], :int # FIXME pointer should be CramFd
+
+=begin
+
+attach_function \
+  :cram_flush,
+  [CramFd],
+  :int
+
+attach_function \
+  :cram_eof,
+  [CramFd],
+  :int
+
+attach_function \
+  :cram_set_option,
+  [CramFd, HtsFmtOption, ...], # vararg!
+  :int
+
+attach_function \
+  :cram_set_voption,
+  [CramFd, HtsFmtOption, VaList],
+  :int
+
+attach_function \
+  :cram_set_header,
+  [CramFd, SamHdr.by_ref],
+  :int
+
+attach_function \
+  :cram_check_eof = :cram_check_EOF,
+  [CramFd], :int
+
+attach_function \
+  :cram_get_refs,
+  [HtsFile],
+  RefsT # what is RefsT
+
+=end
+  end
+end

data/lib/hts/libhts/hfile.rb

@@ -6,13 +6,13 @@ module HTS
     attach_function \
       :hopen,
       %i[string string varargs],
-      :HFILE
+      HFILE.by_ref
 
     # Associate a stream with an existing open file descriptor
     attach_function \
       :hdopen,
       %i[int string],
-      :HFILE
+      HFILE.by_ref
 
     # Report whether the file name or URL denotes remote storage
     attach_function \
@@ -29,55 +29,63 @@ module HTS
     # Flush (for output streams) and close the stream
     attach_function \
       :hclose,
-      [:HFILE],
+      [HFILE],
       :int
 
     # Close the stream, without flushing or propagating errors
     attach_function \
       :hclose_abruptly,
-      [:HFILE],
+      [HFILE],
       :void
 
     # Reposition the read/write stream offset
     attach_function \
       :hseek,
-      %i[HFILE off_t int],
+      [HFILE, :off_t, :int],
       :off_t
 
+    # Report the current stream offset
+    def self.htell(fp)
+      # TODO: This is a hack. Is this OK?
+      bg = FFI::Pointer.new(:int, fp.pointer.address + fp.offset_of(:begin)).read_int
+      bf = FFI::Pointer.new(:int, fp.pointer.address + fp.offset_of(:buffer)).read_int
+      fp[:offset] + (bg - bf)
+    end
+
     # Read from the stream until the delimiter, up to a maximum length
     attach_function \
       :hgetdelim,
-      %i[string size_t int HFILE],
+      [:string, :size_t, :int, HFILE],
       :ssize_t
 
     # Read a line from the stream, up to a maximum length
     attach_function \
       :hgets,
-      %i[string int HFILE],
+      [:string, :int, HFILE],
       :string
 
     # Peek at characters to be read without removing them from buffers
     attach_function \
       :hpeek,
-      %i[HFILE pointer size_t],
+      [HFILE, :pointer, :size_t],
       :ssize_t
 
     # For writing streams, flush buffered output to the underlying stream
     attach_function \
       :hflush,
-      [:HFILE],
+      [HFILE],
       :int
 
     # For hfile_mem: get the internal buffer and it's size from a hfile
     attach_function \
       :hfile_mem_get_buffer,
-      %i[HFILE pointer],
+      [HFILE, :pointer],
       :string
 
     # For hfile_mem: get the internal buffer and it's size from a hfile.
     attach_function \
       :hfile_mem_steal_buffer,
-      %i[HFILE pointer],
+      [HFILE, :pointer],
       :string
   end
 end

data/lib/hts/libhts/hts.rb

@@ -61,7 +61,7 @@ module HTS
     # Determine format by peeking at the start of a file
     attach_function \
       :hts_detect_format,
-      [:HFILE, HtsFormat],
+      [HFILE, HtsFormat],
       :int
 
     # Get a human-readable description of the file format
@@ -86,7 +86,7 @@ module HTS
     # Open an existing stream as a SAM/BAM/CRAM/VCF/BCF/etc file
     attach_function \
       :hts_hopen,
-      %i[HFILE string string],
+      [HFILE, :string, :string],
       HtsFile.by_ref
 
     # For output streams, flush any buffered data

data/lib/hts/libhts/sam_funcs.rb

@@ -345,7 +345,8 @@ module HTS
     # Get the next read from a SAM/BAM/CRAM iterator
     def self.sam_itr_next(htsfp, itr, r)
       # FIXME: check if htsfp is compressed BGZF
-      hts_log_error("Null iterator") if itr.null?
+      raise("Null iterator") if itr.null?
+
       # FIXME: check multi
       hts_itr_next(htsfp[:fp][:bgzf], itr, r, htsfp)
     end

data/lib/hts/libhts.rb

@@ -23,12 +23,13 @@ end
 require_relative "libhts/constants"
 
 # This is alphabetical order.
+require_relative "libhts/kfunc"
 require_relative "libhts/bgzf"
-require_relative "libhts/faidx"
 require_relative "libhts/hfile"
 require_relative "libhts/hts"
 require_relative "libhts/sam"
-require_relative "libhts/kfunc"
-require_relative "libhts/tbx"
+require_relative "libhts/cram"
 require_relative "libhts/vcf"
+require_relative "libhts/tbx"
+require_relative "libhts/faidx"
 require_relative "libhts/thread_pool"

data/lib/hts/tabix.rb

@@ -1,28 +1,53 @@
-# frozen_string_literal: true
+require_relative "../htslib"
 
-# Based on hts-python
-# https://github.com/quinlan-lab/hts-python
+require_relative "hts"
 
 module HTS
-  class Tabix
-    class << self
-      alias open new
+  class Tabix < Hts
+    include Enumerable
+
+    attr_reader :file_name
+
+    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
-      # IO like API
+
+    def initialize(file_name, threads: nil)
       if block_given?
-        begin
-          yield self
-        ensure
-          close
-        end
+        message = "HTS::Tabix.new() dose not take block; Please use HTS::Tabix.open() instead"
+        raise message
       end
-    end
 
-    def build; end
+      @file_name = file_name
+
+      # NOTE: Do not check for the existence of local files, since file_names may be remote URIs.
 
-    def sequences; end
+      @mode     = "r"
+      @hts_file = LibHTS.hts_open(@file_name, @mode)
 
-    # def __call__\
+      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
+    end
+
+    def close
+      LibHTS.hts_close(@hts_file)
+      @hts_file = nil
+    end
+
+    def closed?
+      @hts_file.nil?
+    end
   end
 end

data/lib/hts/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTS
-  VERSION = "0.0.8"
+  VERSION = "0.0.10"
 end

data/lib/htslib.rb

@@ -37,9 +37,9 @@ module HTS
   # You can change the path of the shared library with `HTS.lib_path=`
   # before calling the LibHTS module.
   autoload :LibHTS, "hts/libhts"
-end
 
-require_relative "hts/bam"
-require_relative "hts/faidx"
-require_relative "hts/tabix"
-require_relative "hts/bcf"
+  autoload :Bam,    "hts/bam"
+  autoload :Bcf,    "hts/bcf"
+  autoload :Tabix,  "hts/tabix"
+  autoload :Faidx,  "hts/faidx"
+end