htslib 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93ee916dafed0ba04e486a59c81d2bd9befbceda3d679ef820e32d8817597afe
-  data.tar.gz: 7dda13879d0c3707354ab69fe9967f60f0300c1971011218a5cf79e5e211ee25
+  metadata.gz: ea47a473d63b90fd2b1db4ecd65aa1ef38d47bbe5624e24ac583b5329301e5cb
+  data.tar.gz: aab96376972d7b0a587978484b22e41ee049ea742cba937cd57c66a9c0c42f2a
 SHA512:
-  metadata.gz: 8cf68e9276f353bdea4389f5584066870a4887f07891387cf143408cf215c43232f2c390c08b80c57225a8d8b3722a9dcc5ba5cc3cc716079cf004bd34df0da0
-  data.tar.gz: f30abf9c0d0dd07201e150dea5ec6976e7d968bc2f6bf2c347c1dec18cdfaaa5c141793208587f1629fa3cefeaaadd268083a105ab42dd450ce2ac8cfa0e2d7e
+  metadata.gz: 76d9aa699d0176557d8e44171018b132fc4df2c0e1f47a9784388693103799cf920c2ae437fb97f8429422a1edb5ebd43eae7b28a1f18452a5eeeac38244a981
+  data.tar.gz: f2f1d50099a66e71574c4019e66452dd100371cbdc7d08b144856bab8f59f04aac4e207585534f26e29a06342a7fafe5c3ea0fb0d0e2e8dd9ed1822ddbcbdfe8

data/lib/hts/bam/{aux.rb → auxi.rb}

@@ -1,5 +1,11 @@
 # frozen_string_literal: true
 
+# Q. Why is the file name auxi.rb and not aux.rb?
+#
+# A. This is for compatibility with Windows.
+# In Windows, aux is a reserved word
+# You cannot create a file named aux.
+
 module HTS
   class Bam < Hts
     # Auxiliary record data

data/lib/hts/bam/record.rb

@@ -2,7 +2,7 @@
 
 require_relative "flag"
 require_relative "cigar"
-require_relative "aux"
+require_relative "auxi"
 
 module HTS
   class Bam < Hts

data/lib/hts/libhts/constants.rb

@@ -195,7 +195,7 @@ module HTS
         :reg,            :string,
         :intervals,      :pointer, # hts_pair_pos_t
         :tid,            :int,
-        :count,          :uint32_t,
+        :count,          :uint32,
         :min_beg,        :hts_pos_t,
         :max_end,        :hts_pos_t
     end
@@ -352,7 +352,7 @@ module HTS
         :qpos,           :int32_t,
         :indel,          :int,
         :level,          :int,
-        :_flags,         :uint32_t, # bit_fields
+        :_flags,         :uint32, # bit_fields
         :cd,             BamPileupCd,
         :cigar_ind,      :int
 
@@ -506,8 +506,8 @@ module HTS
         :rlen,           :hts_pos_t,
         :rid,            :int32_t,
         :qual,           :float,
-        :_n_info_allele, :uint32_t,
-        :_n_fmt_sample,  :uint32_t,
+        :_n_info_allele, :uint32,
+        :_n_fmt_sample,  :uint32,
         :shared,         KString,
         :indiv,          KString,
         :d,              BcfDec,

data/lib/hts/libhts/cram.rb

@@ -7,6 +7,8 @@ module HTS
     typedef :pointer, :cram_block
     typedef :pointer, :cram_metrics
 
+    # cram_fd
+
     attach_function \
       :cram_fd_get_header,
       [:cram_fd],
@@ -82,6 +84,8 @@ module HTS
       [:cram_fd],
       :int
 
+    # cram_block
+
     attach_function \
       :cram_block_get_content_id,
       [:cram_block],
@@ -157,71 +161,88 @@ module HTS
       %i[cram_block size_t],
       :void
 
+    # Computes the size of a cram block, including the block header itself.
     attach_function \
       :cram_block_size,
       [:cram_block],
       :uint32
 
+    # Renumbers RG numbers in a cram compression header.
     attach_function \
       :cram_transcode_rg,
       %i[cram_fd cram_fd cram_container int pointer pointer],
       :int
 
+    # Copies the blocks representing the next num_slice slices from a
+    # container from 'in' to 'out'.
     attach_function \
       :cram_copy_slice,
       %i[cram_fd cram_fd int32],
       :int
 
+    # Returns the number of cram blocks within this slice.
     attach_function \
       :cram_slice_hdr_get_num_blocks,
       [:pointer],
       :int32
 
+    # Returns the block content_id for the block containing an embedded
+    # reference sequence.
     attach_function \
       :cram_slice_hdr_get_embed_ref_id,
       [:pointer],
       :int
 
+    # Returns slice reference ID, start and span (length) coordinates.
     attach_function \
       :cram_slice_hdr_get_coords,
       %i[pointer pointer pointer pointer],
       :void
 
+    # Decodes a slice header from a cram block.
     attach_function \
       :cram_decode_slice_header,
       %i[pointer pointer],
       :pointer
 
+    # Frees a cram_block_slice_hdr structure.
     attach_function \
       :cram_free_slice_header,
       [:pointer],
       :void
 
+    # Allocates a new cram_block structure with a specified content_type
+    # and id.
     attach_function \
       :cram_new_block,
       [CramContentType, :int],
       :cram_block
 
+    # Reads a block from a cram file.
     attach_function \
       :cram_read_block,
       [:cram_fd],
       :cram_block
 
+    # Writes a CRAM block.
     attach_function \
       :cram_write_block,
       %i[cram_fd cram_block],
       :int
 
+    # Frees a CRAM block, deallocating internal data too.
     attach_function \
       :cram_free_block,
       [:cram_block],
       :void
 
+    # Uncompresses a CRAM block, if compressed.
     attach_function \
       :cram_uncompress_block,
       [:cram_block],
       :int
 
+    # Compresses a block.
     attach_function \
       :cram_compress_block,
       %i[cram_fd cram_block cram_metrics int int],
@@ -232,6 +253,8 @@ module HTS
     #   %i[cram_fd cram_slice cram_block cram_metrics int int],
     #   :int
 
+    # Creates a new container, specifying the maximum number of slices
+    # and records permitted.
     attach_function \
       :cram_new_container,
       %i[int int],
@@ -242,16 +265,20 @@ module HTS
       [:cram_container],
       :void
 
+    # Reads a container header.
     attach_function \
       :cram_read_container,
       [:cram_fd],
       :cram_container
 
+    # Writes a container structure.
     attach_function \
       :cram_write_container,
       %i[cram_fd cram_container],
       :int
 
+    # Stores the container structure in dat and returns *size as the
+    # number of bytes written to dat[].
     attach_function \
       :cram_store_container,
       %i[cram_fd cram_container string pointer],
@@ -262,61 +289,73 @@ module HTS
       [:cram_container],
       :int
 
+    # Opens a CRAM file for read (mode "rb") or write ("wb").
     attach_function \
       :cram_open,
       %i[string string],
       :cram_fd
 
+    # Opens an existing stream for reading or writing.
     attach_function \
       :cram_dopen,
       %i[pointer string string],
       :cram_fd
 
+    # Closes a CRAM file.
     attach_function \
       :cram_close,
       [:cram_fd],
       :int
 
+    # Seek within a CRAM file.
     attach_function \
       :cram_seek,
       %i[pointer off_t int],
       :int # FIXME: pointer should be :cram_fd
 
+    # Flushes a CRAM file.
     attach_function \
       :cram_flush,
       [:cram_fd],
       :int
 
+    # Checks for end of file on a cram_fd stream.
     attach_function \
       :cram_eof,
       [:cram_fd],
       :int
 
+    # Sets options on the cram_fd.
     attach_function \
       :cram_set_option,
       [:cram_fd, HtsFmtOption, :varargs],
       :int
 
+    # Sets options on the cram_fd.
     attach_function \
       :cram_set_voption,
       [:cram_fd, HtsFmtOption, :pointer], # va_list
       :int
 
+    # Attaches a header to a cram_fd.
     attach_function \
       :cram_set_header,
       [:cram_fd, SamHdr.by_ref],
       :int
 
+    # Check if this file has a proper EOF block
     attach_function \
       :cram_check_EOF,
       [:cram_fd],
       :int
 
+    # As int32_decoded/encode, but from/to blocks instead of cram_fd
     attach_function \
       :int32_put_blk,
       %i[cram_block int32_t],
       :int
 
+    # Returns the refs_t structure used by a cram file handle.
     attach_function \
       :cram_get_refs,
       [HtsFile.by_ref],

data/lib/hts/libhts/sam_funcs.rb

@@ -58,58 +58,72 @@ module HTS
     # macros
     # function-like macros
     class << self
+      # Get whether the query is on the reverse strand
       def bam_is_rev(b)
         b[:core][:flag] & BAM_FREVERSE != 0
       end
 
+      # Get whether the query's mate is on the reverse strand
       def bam_is_mrev(b)
         b[:core][:flag] & BAM_FMREVERSE != 0
       end
 
+      # Get the name of the query
       def bam_get_qname(b)
         b[:data]
       end
 
+      # Get the CIGAR array
       def bam_get_cigar(b)
         b[:data] + b[:core][:l_qname]
       end
 
+      # Get query sequence
       def bam_get_seq(b)
         b[:data] + (b[:core][:n_cigar] << 2) + b[:core][:l_qname]
       end
 
+      # Get query quality
       def bam_get_qual(b)
         b[:data] + (b[:core][:n_cigar] << 2) + b[:core][:l_qname] + ((b[:core][:l_qseq] + 1) >> 1)
       end
 
+      # Get auxiliary data
       def bam_get_aux(b)
         b[:data] + (b[:core][:n_cigar] << 2) + b[:core][:l_qname] + ((b[:core][:l_qseq] + 1) >> 1) + b[:core][:l_qseq]
       end
 
+      # Get length of auxiliary data
       def bam_get_l_aux(b)
         b[:l_data] - (b[:core][:n_cigar] << 2) - b[:core][:l_qname] - b[:core][:l_qseq] - ((b[:core][:l_qseq] + 1) >> 1)
       end
 
+      # Get a base on read
       def bam_seqi(s, i)
         (s[i >> 1].read_uint8 >> ((~i & 1) << 2)) & 0xf
       end
 
+      # Modifies a single base in the bam structure.
       def bam_set_seqi(s, i, b)
         s[i >> 1] = (s[i >> 1] & (0xf0 >> ((~i & 1) << 2))) | ((b) << ((~i & 1) << 2))
       end
 
+      # Returns the SAM formatted text of the \@HD header line
       def sam_hdr_find_hd(h, ks)
         sam_hdr_find_line_id(h, "HD", nil, nil, ks)
       end
 
+      # Returns the value associated with a given \@HD line tag
       def sam_hdr_find_tag_hd(h, key, ks)
         sam_hdr_find_tag_id(h, "HD", nil, nil, key, ks)
       end
 
+      # Adds or updates tags on the header \@HD line
       def sam_hdr_update_hd(h, *args)
         sam_hdr_update_line(h, "HD", nil, nil, *args, nil)
       end
 
+      # Removes the \@HD line tag with the given key
       def sam_hdr_remove_tag_hd(h, key)
         sam_hdr_remove_tag_id(h, "HD", nil, nil, key)
       end
@@ -122,6 +136,8 @@ module HTS
       alias bam_itr_querys sam_itr_querys
       alias bam_itr_next sam_itr_next
 
+      # Load/build .csi or .bai BAM index file.  Does not work with CRAM.
+      # It is recommended to use the sam_index_* functions below instead.
       def bam_index_load(fn)
         hts_idx_load(fn, HTS_FMT_BAI)
       end

data/lib/hts/libhts/vcf.rb

@@ -2,41 +2,50 @@
 
 module HTS
   module LibHTS
+    # Create an empty BCF header.
     attach_function \
       :bcf_hdr_init,
       [:string],
       BcfHdr.by_ref
 
+    # Destroy a BCF header struct
     attach_function \
       :bcf_hdr_destroy,
       [BcfHdr],
       :void
 
+    # Allocate and initialize a bcf1_t object.
     attach_function \
       :bcf_init,
       [],
       Bcf1.by_ref
 
+    # Deallocate a bcf1_t object
     attach_function \
       :bcf_destroy,
       [Bcf1],
       :void
 
+    # Same as bcf_destroy() but frees only the memory allocated by bcf1_t,
+    # not the bcf1_t object itself.
     attach_function \
       :bcf_empty,
       [Bcf1],
       :void
 
+    # Make the bcf1_t object ready for next read.
     attach_function \
       :bcf_clear,
       [Bcf1],
       :void
 
+    # Read a VCF or BCF header
     attach_function \
       :bcf_hdr_read,
       [HtsFile],
       BcfHdr.by_ref
 
+    # for more efficient VCF parsing when only one/few samples are needed
     attach_function \
       :bcf_hdr_set_samples,
       [BcfHdr, :string, :int],
@@ -47,36 +56,43 @@ module HTS
       [BcfHdr, Bcf1],
       :int
 
+    # Write a VCF or BCF header
     attach_function \
       :bcf_hdr_write,
       [HtsFile, BcfHdr],
       :int
 
+    # Parse VCF line contained in kstring and populate the bcf1_t struct
     attach_function \
       :vcf_parse,
       [KString, BcfHdr, Bcf1],
       :int
 
+    # Complete the file opening mode, according to its extension.
     attach_function \
       :vcf_open_mode,
       %i[string string string],
       :int
 
+    # The opposite of vcf_parse.
     attach_function \
       :vcf_format,
       [BcfHdr, Bcf1, KString],
       :int
 
+    # Read next VCF or BCF record
     attach_function \
       :bcf_read,
       [HtsFile, BcfHdr, Bcf1],
       :int
 
+    # unpack/decode a BCF record (fills the bcf1_t::d field)
     attach_function \
       :bcf_unpack,
       [Bcf1, :int],
       :int
 
+    # Create a copy of BCF record.
     attach_function \
       :bcf_dup,
       [Bcf1],
@@ -87,80 +103,95 @@ module HTS
       [Bcf1, Bcf1],
       Bcf1.by_ref
 
+    # Write one VCF or BCF record.
     attach_function \
       :bcf_write,
       [HtsFile, BcfHdr, Bcf1],
       :int
 
+    # Read a VCF format header
     attach_function \
       :vcf_hdr_read,
       [HtsFile],
       BcfHdr.by_ref
 
+    # Write a VCF format header
     attach_function \
       :vcf_hdr_write,
       [HtsFile, BcfHdr],
       :int
 
+    # Read a record from a VCF file
     attach_function \
       :vcf_read,
       [HtsFile, BcfHdr, Bcf1],
       :int
 
+    # Write a record to a VCF file
     attach_function \
       :vcf_write,
       [HtsFile, BcfHdr, Bcf1],
       :int
 
+    # Helper function for the bcf_itr_next() macro
     attach_function \
       :bcf_readrec,
       [BGZF, :pointer, :pointer, :pointer, :hts_pos_t, :hts_pos_t],
       :int
 
+    # Write a line to a VCF file
     attach_function \
       :vcf_write_line,
       [HtsFile, KString],
       :int
 
+    # Header querying and manipulation routines
+
+    # Create a new header using the supplied template
     attach_function \
       :bcf_hdr_dup,
       [BcfHdr],
       BcfHdr.by_ref
 
-    # DEPRECATED
+    # DEPRECATED please use bcf_hdr_merge instead
     #
     # attach_function \
     #   :bcf_hdr_combine,
     #   [BcfHdr, BcfHdr],
     #   :int
 
+    # Copy header lines from src to dst, see also bcf_translate()
     attach_function \
       :bcf_hdr_merge,
       [BcfHdr, BcfHdr],
       BcfHdr.by_ref
 
+    # Add a new sample.
     attach_function \
       :bcf_hdr_add_sample,
       [BcfHdr, :string],
       :int
 
+    # Read VCF header from a file and update the header
     attach_function \
       :bcf_hdr_set,
       [BcfHdr, :string],
       :int
 
+    # Appends formatted header text to _str_.
     attach_function \
       :bcf_hdr_format,
       [BcfHdr, :int, KString],
       :int
 
-    # DEPRECATED
+    # DEPRECATED use bcf_hdr_format() instead
     #
     # attach_function \
     #   :bcf_hdr_fmt_text,
     #   [BcfHdr, :int, :pointer],
     #   :string
 
+    # Append new VCF header line
     attach_function \
       :bcf_hdr_append,
       [BcfHdr, :string],
@@ -171,26 +202,31 @@ module HTS
       [BcfHdr, :string, :varargs],
       :int
 
+    # VCF version, e.g. VCFv4.2
     attach_function \
       :bcf_hdr_get_version,
       [BcfHdr],
       :string
 
+    # Set version in bcf header
     attach_function \
       :bcf_hdr_set_version,
       [BcfHdr, :string],
       :int
 
+    # Remove VCF header tag
     attach_function \
       :bcf_hdr_remove,
       [BcfHdr, :int, :string],
       :void
 
+    # Creates a new copy of the header removing unwanted samples
     attach_function \
       :bcf_hdr_subset,
       [BcfHdr, :int, :pointer, :pointer],
       BcfHdr.by_ref
 
+    # Creates a list of sequence names.
     attach_function \
       :bcf_hdr_seqnames,
       [BcfHdr, :pointer],
@@ -201,16 +237,19 @@ module HTS
       [BcfHdr, :string],
       :int
 
+    # Synchronize internal header structures
     attach_function \
       :bcf_hdr_sync,
       [BcfHdr],
       :int
 
+    # parse a single line of VCF textual header
     attach_function \
       :bcf_hdr_parse_line,
       [BcfHdr, :string, :pointer],
       BcfHrec.by_ref
 
+    # Convert a bcf header record to string form
     attach_function \
       :bcf_hrec_format,
       [BcfHrec, KString],
@@ -221,21 +260,25 @@ module HTS
       [BcfHdr, BcfHrec],
       :int
 
+    # Get header line info
     attach_function \
       :bcf_hdr_get_hrec,
       [BcfHdr, :int, :string, :string, :string],
       BcfHrec.by_ref
 
+    # Duplicate a header record
     attach_function \
       :bcf_hrec_dup,
       [BcfHrec],
       BcfHrec.by_ref
 
+    # Add a new header record key
     attach_function \
       :bcf_hrec_add_key,
       [BcfHrec, :string, :size_t],
       :int
 
+    # Set a header record value
     attach_function \
       :bcf_hrec_set_val,
       [BcfHrec, :int, :string, :size_t, :int],
@@ -246,46 +289,57 @@ module HTS
       [BcfHrec, :string],
       :int
 
+    # Add an IDX header record
     attach_function \
       :hrec_add_idx,
       [BcfHrec, :int],
       :int
 
+    # Free up a header record and associated structures
     attach_function \
       :bcf_hrec_destroy,
       [BcfHrec],
       :void
 
+    # Individual record querying and manipulation routines
+
+    # See the description of bcf_hdr_subset()
     attach_function \
       :bcf_subset,
       [BcfHdr, Bcf1, :int, :pointer],
       :int
 
+    # Translate tags ids to be consistent with different header.
     attach_function \
       :bcf_translate,
       [BcfHdr, BcfHdr, Bcf1],
       :int
 
+    # Get variant types in a BCF record
     attach_function \
       :bcf_get_variant_types,
       [Bcf1],
       :int
 
+    # Get variant type in a BCF record, for a given allele
     attach_function \
       :bcf_get_variant_type,
       [Bcf1, :int],
       :int
 
+    # Check for presence of variant types in a BCF record
     attach_function \
       :bcf_has_variant_types,
       [Bcf1, :uint32, :int],
       :int
 
+    # Check for presence of variant types in a BCF record, for a given allele
     attach_function \
       :bcf_has_variant_type,
       [Bcf1, :int, :uint32],
       :int
 
+    # Return the number of bases affected by a variant, for a given allele
     attach_function \
       :bcf_variant_length,
       [Bcf1, :int],
@@ -296,26 +350,32 @@ module HTS
       [Bcf1],
       :int
 
+    # Sets the FILTER column
     attach_function \
       :bcf_update_filter,
       [BcfHdr, Bcf1, :pointer, :int],
       :int
 
+    # Adds to the FILTER column
     attach_function \
       :bcf_add_filter,
       [BcfHdr, Bcf1, :int],
       :int
 
+    # Removes from the FILTER column
     attach_function \
       :bcf_remove_filter,
       [BcfHdr, Bcf1, :int, :int],
       :int
 
+    # Returns 1 if present, 0 if absent, or -1 if filter does not exist.
+    # "PASS" and "." can be used interchangeably.
     attach_function \
       :bcf_has_filter,
       [BcfHdr, Bcf1, :string],
       :int
 
+    # Update REF and ALT column
     attach_function \
       :bcf_update_alleles,
       [BcfHdr, Bcf1, :pointer, :int],
@@ -326,6 +386,7 @@ module HTS
       [BcfHdr, Bcf1, :string],
       :int
 
+    # Sets new ID string
     attach_function \
       :bcf_update_id,
       [BcfHdr, Bcf1, :string],
@@ -336,6 +397,7 @@ module HTS
       [BcfHdr, Bcf1, :string],
       :int
 
+    # Functions for updating INFO fields
     attach_function \
       :bcf_update_info,
       [BcfHdr, Bcf1, :string, :pointer, :int, :int],
@@ -346,11 +408,13 @@ module HTS
       [BcfHdr, Bcf1, :string, :pointer, :int],
       :int
 
+    # Functions for updating FORMAT fields
     attach_function \
       :bcf_update_format,
       [BcfHdr, Bcf1, :string, :pointer, :int, :int],
       :int
 
+    # Returns pointer to FORMAT's field data
     attach_function \
       :bcf_get_fmt,
       [BcfHdr, Bcf1, :string],
@@ -361,6 +425,7 @@ module HTS
       [BcfHdr, Bcf1, :string],
       BcfInfo.by_ref
 
+    # Returns pointer to FORMAT/INFO field data given the header index instead of the string ID
     attach_function \
       :bcf_get_fmt_id,
       [Bcf1, :int],
@@ -371,6 +436,7 @@ module HTS
       [Bcf1, :int],
       BcfInfo.by_ref
 
+    # get INFO values
     attach_function \
       :bcf_get_info_values,
       [BcfHdr, Bcf1, :string, :pointer, :pointer, :int],
@@ -386,11 +452,15 @@ module HTS
       [BcfHdr, Bcf1, :string, :pointer, :pointer, :int],
       :int
 
+    # Helper functions
+
+    # Translates string into numeric ID
     attach_function \
       :bcf_hdr_id2int,
       [BcfHdr, :int, :string],
       :int
 
+    # Convert BCF FORMAT data to string form
     attach_function \
       :bcf_fmt_array,
       [KString, :int, :int, :pointer],
@@ -401,51 +471,63 @@ module HTS
       [KString, :pointer],
       :uint8_t
 
+    # Encode a variable-length char array in BCF format
     attach_function \
       :bcf_enc_vchar,
       [KString, :int, :string],
       :int
 
+    # Encode a variable-length integer array in BCF format
     attach_function \
       :bcf_enc_vint,
       [KString, :int, :pointer, :int],
       :int
 
+    # Encode a variable-length float array in BCF format
     attach_function \
       :bcf_enc_vfloat,
       [KString, :int, :pointer],
       :int
 
+    # BCF index
+
+    # Load a BCF index from a given index file name
     attach_function \
       :bcf_index_load2,
       %i[string string],
       HtsIdx.by_ref
 
+    # Load a BCF index from a given index file name
     attach_function \
       :bcf_index_load3,
       %i[string string int],
       HtsIdx.by_ref
 
+    # Generate and save an index file
     attach_function \
       :bcf_index_build,
       %i[string int],
       :int
 
+    # Generate and save an index to a specific file
     attach_function \
       :bcf_index_build2,
       %i[string string int],
       :int
 
+    # Generate and save an index to a specific file
     attach_function \
       :bcf_index_build3,
       %i[string string int int],
       :int
 
+    # Initialise fp->idx for the current format type, for VCF and BCF files.
     attach_function \
       :bcf_idx_init,
       [HtsFile, BcfHdr, :int, :string],
       :int
 
+    # Writes the index initialised with bcf_idx_init to disk.
     attach_function \
       :bcf_idx_save,
       [HtsFile],

data/lib/hts/libhts/vcf_funcs.rb

@@ -87,105 +87,130 @@ module HTS
     BCF_UN_ALL  = (BCF_UN_SHR | BCF_UN_FMT) # everything
 
     class << self
+      # Get number of samples
       def bcf_hdr_nsamples(hdr)
         hdr[:n][BCF_DT_SAMPLE]
       end
 
+      # Function for updating INFO fields
       def bcf_update_info_int32(hdr, line, key, values, n)
         bcf_update_info(hdr, line, key, values, n, BCF_HT_INT)
       end
 
+      # Function for updating INFO fields
       def bcf_update_info_float(hdr, line, key, values, n)
         bcf_update_info(hdr, line, key, values, n, BCF_HT_REAL)
       end
 
+      # Function for updating INFO fields
       def bcf_update_info_flag(hdr, line, key, string, n)
         bcf_update_info(hdr, line, key, string, n, BCF_HT_FLAG)
       end
 
+      # Function for updating INFO fields
       def bcf_update_info_string(hdr, line, key, string)
         bcf_update_info(hdr, line, key, string, 1, BCF_HT_STR)
       end
 
+      # Function for updating FORMAT fields
       def bcf_update_format_int32(hdr, line, key, values, n)
         bcf_update_format(hdr, line, key, values, n,
                           BCF_HT_INT)
       end
 
+      # Function for updating FORMAT fields
       def bcf_update_format_float(hdr, line, key, values, n)
         bcf_update_format(hdr, line, key, values, n,
                           BCF_HT_REAL)
       end
 
+      # Function for updating FORMAT fields
       def bcf_update_format_char(hdr, line, key, values, n)
         bcf_update_format(hdr, line, key, values, n,
                           BCF_HT_STR)
       end
 
+      # Function for updating FORMAT fields
       def bcf_update_genotypes(hdr, line, gts, n)
         bcf_update_format(hdr, line, "GT", gts, n, BCF_HT_INT)
       end
 
+      # Macro for setting genotypes correctly
       def bcf_gt_phased(idx)
         ((idx + 1) << 1 | 1)
       end
 
+      # Macro for setting genotypes correctly
       def bcf_gt_unphased(idx)
         ((idx + 1) << 1)
       end
 
+      # Macro for setting genotypes correctly
       def bcf_gt_missing
         0
       end
 
+      # Macro for setting genotypes correctly
       def bcf_gt_is_missing(val)
         (val >> 1 ? 0 : 1)
       end
 
+      # Macro for setting genotypes correctly
       def bcf_gt_is_phased(idx)
         (idx & 1)
       end
 
+      # Macro for setting genotypes correctly
       def bcf_gt_allele(val)
         ((val >> 1) - 1)
       end
 
+      # Conversion between alleles indexes to Number=G genotype index (assuming diploid, all 0-based)
       def bcf_alleles2gt(a, b)
         ((a) > (b) ? (a * (a + 1) / 2 + b) : (b * (b + 1) / 2 + a))
       end
 
+      # Get INFO values
       def bcf_get_info_int32(hdr, line, tag, dst, ndst)
         bcf_get_info_values(hdr, line, tag, dst, ndst, BCF_HT_INT)
       end
 
+      # Get INFO values
       def bcf_get_info_float(hdr, line, tag, dst, ndst)
         bcf_get_info_values(hdr, line, tag, dst, ndst, BCF_HT_REAL)
       end
 
+      # Get INFO values
       def bcf_get_info_string(hdr, line, tag, dst, ndst)
         bcf_get_info_values(hdr, line, tag, dst, ndst, BCF_HT_STR)
       end
 
+      # Get INFO values
       def bcf_get_info_flag(hdr, line, tag, dst, ndst)
         bcf_get_info_values(hdr, line, tag, dst, ndst, BCF_HT_FLAG)
       end
 
+      # Get FORMAT values
       def bcf_get_format_int32(hdr, line, tag, dst, ndst)
         bcf_get_format_values(hdr, line, tag, dst, ndst, BCF_HT_INT)
       end
 
+      # Get FORMAT values
       def bcf_get_format_float(hdr, line, tag, dst, ndst)
         bcf_get_format_values(hdr, line, tag, dst, ndst, BCF_HT_REAL)
       end
 
+      # Get FORMAT values
       def bcf_get_format_char(hdr, line, tag, dst, ndst)
         bcf_get_format_values(hdr, line, tag, dst, ndst, BCF_HT_STR)
       end
 
+      # Get FORMAT values
       def bcf_get_genotypes(hdr, line, dst, ndst)
         bcf_get_format_values(hdr, line, "GT", dst, ndst, BCF_HT_INT)
       end
 
+      # Translates numeric ID into string
       def bcf_hdr_int2id(hdr, type, int_id)
         LibHTS::BcfIdpair.new(
           hdr[:id][type].to_ptr +
@@ -193,10 +218,12 @@ module HTS
         )[:key]
       end
 
+      # Translates sequence names (chromosomes) into numeric ID
       def bcf_hdr_name2id(hdr, id)
         bcf_hdr_id2int(hdr, BCF_DT_CTG, id)
       end
 
+      # Translates numeric ID to sequence name
       def bcf_hdr_id2name(hdr, rid)
         return nil if hdr.null? || rid < 0 || rid >= hdr[:n][LibHTS::BCF_DT_CTG]
 
@@ -206,6 +233,7 @@ module HTS
         )[:key]
       end
 
+      # Macro for accessing bcf_idinfo_t
       def bcf_hdr_id2length(hdr, type, int_id)
         LibHTS::BcfIdpair.new(
           hdr[:id][LibHTS::BCF_DT_ID].to_ptr +
@@ -213,6 +241,7 @@ module HTS
         )[:val][:info][type] >> 8 & 0xf
       end
 
+      # Macro for accessing bcf_idinfo_t
       def bcf_hdr_id2number(hdr, type, int_id)
         LibHTS::BcfIdpair.new(
           hdr[:id][LibHTS::BCF_DT_ID].to_ptr +
@@ -220,6 +249,7 @@ module HTS
         )[:val][:info][type] >> 12
       end
 
+      # Macro for accessing bcf_idinfo_t
       def bcf_hdr_id2type(hdr, type, int_id)
         LibHTS::BcfIdpair.new(
           hdr[:id][LibHTS::BCF_DT_ID].to_ptr +
@@ -227,6 +257,7 @@ module HTS
         )[:val][:info][type] >> 4 & 0xf
       end
 
+      # Macro for accessing bcf_idinfo_t
       def bcf_hdr_id2coltype(hdr, type, int_id)
         LibHTS::BcfIdpair.new(
           hdr[:id][LibHTS::BCF_DT_ID].to_ptr +
@@ -252,10 +283,12 @@ module HTS
         hts_itr_querys(idx, s, @@bcf_hdr_name2id, hdr, @@hts_itr_query, @@bcf_readrec)
       end
 
+      # Load a BCF index
       def bcf_index_load(fn)
         hts_idx_load(fn, HTS_FMT_CSI)
       end
 
+      # Load a BCF index
       def bcf_index_seqnames(idx, hdr, nptr)
         hts_idx_seqnames(idx, nptr, @@bcf_hdr_id2name, hdr)
       end

data/lib/hts/libhts.rb

@@ -15,12 +15,13 @@ module HTS
     end
 
     # @!macro attach_function
+    #   @!scope class
     #   @!method $1(${2--2})
     #   @return [${-1}] the return value of $0
     def self.attach_function(*)
       super
     rescue FFI::NotFoundError => e
-      warn e.message
+      warn e.message if $VERBOSE
     end
   end
 end

data/lib/hts/version.rb

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

data/lib/htslib.rb

@@ -30,9 +30,23 @@ module HTS
 
       warn "htslib shared library '#{name}' not found."
     end
+
+    def search_htslib_windows
+      ENV["HTSLIBDIR"] ||= [
+        RubyInstaller::Runtime.msys2_installation.msys_path,
+        RubyInstaller::Runtime.msys2_installation.mingwarch
+      ].join(File::ALT_SEPARATOR)
+      path = File.expand_path("bin/hts-3.dll", ENV["HTSLIBDIR"])
+      RubyInstaller::Runtime.add_dll_directory(File.dirname(path))
+      path
+    end
   end
 
-  self.lib_path = search_htslib
+  self.lib_path = if Object.const_defined?(:RubyInstaller)
+                    search_htslib_windows
+                  else
+                    search_htslib
+                  end
 
   # You can change the path of the shared library with `HTS.lib_path=`
   # before calling the LibHTS module.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: htslib
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - kojix2
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-08-19 00:00:00.000000000 Z
+date: 2022-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -132,7 +132,7 @@ files:
 - LICENSE.txt
 - README.md
 - lib/hts/bam.rb
-- lib/hts/bam/aux.rb
+- lib/hts/bam/auxi.rb
 - lib/hts/bam/cigar.rb
 - lib/hts/bam/flag.rb
 - lib/hts/bam/header.rb
@@ -169,7 +169,8 @@ files:
 homepage: https://github.com/kojix2/ruby-htslib
 licenses:
 - MIT
-metadata: {}
+metadata:
+  msys2_mingw_dependencies: htslib
 post_install_message: 
 rdoc_options: []
 require_paths: