htslib 0.0.3 → 0.0.4

data/lib/hts/bcf/record.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module HTS
+  class Bcf
+    class Record
+      def initialize(bcf_t, bcf)
+        @bcf1 = bcf_t
+        @bcf = bcf
+        @p1 = FFI::MemoryPointer.new(:pointer) # FIXME: naming
+      end
+
+      attr_reader :p1, :bcf
+
+      def struct
+        @bcf1
+      end
+
+      def to_ptr
+        @bcf.to_ptr
+      end
+
+      # def inspect; end
+
+      def formats; end
+
+      def genotypes; end
+
+      def chrom
+        hdr = @bcf.header.struct
+        rid = @bcf1[:rid]
+
+        return nil if hdr.null? || rid < 0 || rid >= hdr[:n][LibHTS::BCF_DT_CTG]
+
+        LibHTS::BcfIdpair.new(
+          hdr[:id][LibHTS::BCF_DT_CTG].to_ptr +
+          LibHTS::BcfIdpair.size * rid # offset
+        )[:key]
+      end
+
+      def pos
+        @bcf1[:pos] + 1 # FIXME
+      end
+
+      def start
+        @bcf1[:pos]
+      end
+
+      def stop
+        @bcf1[:pos] + @bcf1[:rlen]
+      end
+
+      def id
+        LibHTS.bcf_unpack(@bcf1, LibHTS::BCF_UN_INFO)
+        @bcf1[:d][:id]
+      end
+
+      def filter
+        LibHTS.bcf_unpack(@bcf1, LibHTS::BCF_UN_FLT)
+        d = @bcf1[:d]
+        n_flt = d[:n_flt]
+
+        case n_flt
+        when 0
+          "PASS"
+        when 1
+          i = d[:flt].read_int
+          LibHTS.bcf_hdr_int2id(@bcf.header.struct, LibHTS::BCF_DT_ID, i)
+        when 2
+          d[:flt].get_array_of_int(0, n_flt).map do |i|
+            LibHTS.bcf_hdr_int2id(@bcf.header.struct, LibHTS::BCF_DT_ID, i)
+          end
+        end
+      end
+
+      def qual
+        @bcf1[:qual]
+      end
+
+      def ref
+        LibHTS.bcf_unpack(@bcf1, LibHTS::BCF_UN_STR)
+        @bcf1[:d][:allele].get_pointer(0).read_string
+      end
+
+      def alt
+        LibHTS.bcf_unpack(@bcf1, LibHTS::BCF_UN_STR)
+        @bcf1[:d][:allele].get_array_of_pointer(
+          FFI::TYPE_POINTER.size, @bcf1[:n_allele] - 1
+        ).map { |c| c.read_string }
+      end
+
+      def alleles
+        @bcf1[:d][:allele].get_array_of_pointer(
+          0, @bcf1[:n_allele]
+        ).map { |c| c.read_string }
+      end
+
+      def info
+        LibHTS.bcf_unpack(@bcf1, LibHTS::BCF_UN_SHR)
+        Info.new(self)
+      end
+
+      def format
+        LibHTS.bcf_unpack(@bcf1, LibHTS::BCF_UN_FMT)
+        Format.new(self)
+      end
+
+      def to_s
+        ksr = LibHTS::KString.new
+        if LibHTS.vcf_format(@bcf.header.struct, @bcf1, ksr) == -1
+          raise "Failed to format record"
+        end
+        ksr[:s]
+      end
+    end
+  end
+end

data/lib/hts/bcf.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# Based on hts-python
+# https://github.com/quinlan-lab/hts-python
+
+require_relative "bcf/header"
+require_relative "bcf/record"
+require_relative "bcf/info"
+require_relative "bcf/format"
+require_relative "utils/open_method"
+
+module HTS
+  class Bcf
+    include Enumerable
+    extend Utils::OpenMethod
+
+    attr_reader :file_path, :mode, :header
+    # HtfFile is FFI::BitStruct
+    attr_reader :htf_file
+
+    class << self
+      alias open new
+    end
+
+    def initialize(file_path, mode = "r")
+      file_path = File.expand_path(file_path)
+
+      unless File.exist?(file_path)
+        message = "No such VCF/BCF file - #{file_path}"
+        raise message
+      end
+
+      @file_path = file_path
+      @mode      = mode
+      @htf_file  = LibHTS.hts_open(file_path, mode)
+      @header    = Bcf::Header.new(LibHTS.bcf_hdr_read(htf_file))
+
+      # FIXME: should be defined here?
+      @bcf1      = LibHTS.bcf_init
+
+      # IO like API
+      if block_given?
+        begin
+          yield self
+        ensure
+          close
+        end
+      end
+    end
+
+    def struct
+      htf_file
+    end
+
+    def to_ptr
+      htf_file.to_ptr
+    end
+
+    # Close the current file.
+    def close
+      LibHTS.hts_close(htf_file)
+    end
+
+    def each(&block)
+      while LibHTS.bcf_read(htf_file, header, @bcf1) != -1
+        record = Record.new(@bcf1, self)
+        block.call(record)
+      end
+    end
+
+    def n_samples
+      LibHTS.bcf_hdr_nsamples(header.struct)
+    end
+  end
+end

data/lib/hts/{fai.rb → faidx.rb}

@@ -3,27 +3,17 @@
 # Based on hts-python
 # https://github.com/quinlan-lab/hts-python
 
+require_relative "utils/open_method"
+
 module HTS
-  class Fai
-    # FIXME: API
-    def self.open(path)
-      fai = new(path)
-      if block_given?
-        yield(fai)
-        fai.close
-      else
-        fai
-      end
-    end
+  class Faidx
+    extend Utils::OpenMethod
 
-    def initialize(path)
-      @path = File.expand_path(path)
-      @path.delete_suffix!(".fai")
-      LibHTS.fai_build(@path) unless File.exist?("#{@path}.fai")
-      @fai = LibHTS.fai_load(@path)
-      raise if @fai.null?
+    attr_reader :file_path
 
-      # at_exit{LibHTS.fai_destroy(@fai)}
+    def initialize(file_path)
+      @file_path = File.expand_path(file_path)
+      @fai = LibHTS.fai_load(file_path)
     end
 
     def close
@@ -38,7 +28,10 @@ module HTS
 
     # return the length of the requested chromosome.
     def chrom_size(chrom)
-      raise ArgumentError, "Expect chrom to be String or Symbol" unless chrom.is_a?(String) || chrom.is_a?(Symbol)
+      unless chrom.is_a?(String) || chrom.is_a?(Symbol)
+        # FIXME
+        raise ArgumentError, "Expect chrom to be String or Symbol"
+      end
 
       chrom = chrom.to_s
       result = LibHTS.faidx_seq_len(@fai, chrom)

data/lib/hts/ffi_ext/README.md

@@ -0,0 +1,8 @@
+# Ruby-FFI extensions
+
+* Add syntax sugar
+  * union_layout
+  * struct_layout
+
+* Support for bit fields
+  * [ffi-bitfield](https://github.com/kojix2/ffi-bitfield)

data/lib/hts/ffi_ext/struct.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "ffi/bit_struct"
+
+module FFI
+  class Struct
+    class << self
+      # @example HtsOpt
+      #   class HtsOpt < FFI::Struct
+      #     layout \
+      #       :arg,            :string,
+      #       :opt,            HtsFmtOption,
+      #       :val,
+      #       union_layout(
+      #         :i,            :int,
+      #         :s,            :string
+      #       ),
+      #       :next,           HtsOpt.ptr
+      #   end
+
+      def union_layout(*args)
+        Class.new(FFI::Union) { layout(*args) }
+      end
+
+      # @example HtsFormat
+      #   class HtsFormat < FFI::Struct
+      #     layout \
+      #       :category,          HtsFormatCategory,
+      #       :format,            HtsExactFormat,
+      #       :version,
+      #       struct_layout(
+      #         :major,           :short,
+      #         :minor,           :short
+      #       ),
+      #       :compression,       HtsCompression,
+      #       :compression_level, :short,
+      #       :specific,          :pointer
+      #   end
+
+      def struct_layout(*args)
+        Class.new(FFI::Struct) { layout(*args) }
+      end
+    end
+  end
+end

data/lib/hts/libhts/constants.rb

@@ -362,7 +362,7 @@ module HTS
              :format,    FaiFormatOptions
     end
 
-    # vcf
+    # bcf
 
     class BcfVariant < FFI::Struct
       layout \
@@ -416,7 +416,7 @@ module HTS
 
     class BcfIdinfo < FFI::Struct
       layout \
-        :info,           [:uint8, 3],
+        :info,           [:uint64_t, 3],
         :hrec,           [BcfHrec.ptr, 3],
         :id,             :int
     end
@@ -430,7 +430,7 @@ module HTS
     class BcfHdr < FFI::Struct
       layout \
         :n,              [:int, 3],
-        :id,             [BcfIdpair.ptr, 3],
+        :id,             [:pointer, 3], # BcfIdpair.ptr
         :dict,           [:pointer, 3],
         :samples,        :pointer,
         :hrec,           :pointer,

data/lib/hts/libhts/sam.rb

@@ -15,7 +15,6 @@ module HTS
     BAM_CBACK      = 9
 
     BAM_CIGAR_STR = "MIDNSHP=XB"
-    BAM_CIGAR_STR_PADDED = "MIDNSHP=XB??????"
     BAM_CIGAR_SHIFT = 4
     BAM_CIGAR_MASK  = 0xf
     BAM_CIGAR_TYPE  = 0x3C1A7

data/lib/hts/libhts/vcf.rb

@@ -57,9 +57,116 @@ module HTS
 
     # macros
     class << self
+      alias bcf_open hts_open
+      alias vcf_open hts_open
+      alias bcf_close hts_close
+      alias vcf_close hts_close
+
       def bcf_hdr_nsamples(hdr)
         hdr[:n][BCF_DT_SAMPLE]
       end
+
+      def bcf_update_info_int32(hdr, line, key, values, n)
+        bcf_update_info(hdr, line, key, values, n, BCF_HT_INT)
+      end
+
+      def bcf_update_info_float(hdr, line, key, values, n)
+        bcf_update_info(hdr, line, key, values, n, BCF_HT_REAL)
+      end
+
+      def bcf_update_info_flag(hdr, line, key, string, n)
+        bcf_update_info(hdr, line, key, string, n, BCF_HT_FLAG)
+      end
+
+      def bcf_update_info_string(hdr, line, key, string)
+        bcf_update_info(hdr, line, key, string, 1, BCF_HT_STR)
+      end
+
+      def bcf_update_format_int32(hdr, line, key, values, n)
+        bcf_update_format(hdr, line, key, values, n,
+                          BCF_HT_INT)
+      end
+
+      def bcf_update_format_float(hdr, line, key, values, n)
+        bcf_update_format(hdr, line, key, values, n,
+                          BCF_HT_REAL)
+      end
+
+      def bcf_update_format_char(hdr, line, key, values, n)
+        bcf_update_format(hdr, line, key, values, n,
+                          BCF_HT_STR)
+      end
+
+      def bcf_update_genotypes(hdr, line, gts, n)
+        bcf_update_format(hdr, line, "GT", gts, n, BCF_HT_INT)
+      end
+
+      def bcf_gt_phased(idx)
+        ((idx + 1) << 1 | 1)
+      end
+
+      def bcf_gt_unphased(idx)
+        ((idx + 1) << 1)
+      end
+
+      def bcf_gt_missing
+        0
+      end
+
+      def bcf_gt_is_missing(val)
+        ((val) >> 1 ? 0 : 1)
+      end
+
+      def bcf_gt_is_phased(idx)
+        ((idx) & 1)
+      end
+
+      def bcf_gt_allele(val)
+        (((val) >> 1) - 1)
+      end
+
+      def bcf_alleles2gt(a, b)
+        ((a) > (b) ? (a * (a + 1) / 2 + b) : (b * (b + 1) / 2 + a))
+      end
+
+      def bcf_get_info_int32(hdr, line, tag, dst, ndst)
+        bcf_get_info_values(hdr, line, tag, dst, ndst, BCF_HT_INT)
+      end
+
+      def bcf_get_info_float(hdr, line, tag, dst, ndst)
+        bcf_get_info_values(hdr, line, tag, dst, ndst, BCF_HT_REAL)
+      end
+
+      def bcf_get_info_string(hdr, line, tag, dst, ndst)
+        bcf_get_info_values(hdr, line, tag, dst, ndst, BCF_HT_STR)
+      end
+
+      def bcf_get_info_flag(hdr, line, tag, dst, ndst)
+        bcf_get_info_values(hdr, line, tag, dst, ndst, BCF_HT_FLAG)
+      end
+
+      def bcf_get_format_int32(hdr, line, tag, dst, ndst)
+        bcf_get_format_values(hdr, line, tag, dst, ndst, BCF_HT_INT)
+      end
+
+      def bcf_get_format_float(hdr, line, tag, dst, ndst)
+        bcf_get_format_values(hdr, line, tag, dst, ndst, BCF_HT_REAL)
+      end
+
+      def bcf_get_format_char(hdr, line, tag, dst, ndst)
+        bcf_get_format_values(hdr, line, tag, dst, ndst, BCF_HT_STR)
+      end
+
+      def bcf_get_genotypes(hdr, line, dst, ndst)
+        bcf_get_format_values(hdr, line, "GT", dst, ndst, BCF_HT_INT)
+      end
+
+      def bcf_hdr_int2id(hdr, type, int_id)
+        LibHTS::BcfIdpair.new(
+          hdr[:id][type].to_ptr +
+          LibHTS::BcfIdpair.size * int_id # offsets
+        )[:key]
+      end
     end
 
     # constants

data/lib/hts/libhts.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "ffi_ext/struct"
+
 module HTS
   module LibHTS
     extend FFI::Library
@@ -18,119 +20,9 @@ module HTS
   end
 end
 
-module FFI
-  class Struct
-    class << self
-      # @example HtsOpt
-      #   class HtsOpt < FFI::Struct
-      #     layout \
-      #       :arg,            :string,
-      #       :opt,            HtsFmtOption,
-      #       :val,
-      #       union_layout(
-      #         :i,            :int,
-      #         :s,            :string
-      #       ),
-      #       :next,           HtsOpt.ptr
-      #   end
-
-      def union_layout(*args)
-        Class.new(FFI::Union) { layout(*args) }
-      end
-
-      # @example HtsFormat
-      #   class HtsFormat < FFI::Struct
-      #     layout \
-      #       :category,          HtsFormatCategory,
-      #       :format,            HtsExactFormat,
-      #       :version,
-      #       struct_layout(
-      #         :major,           :short,
-      #         :minor,           :short
-      #       ),
-      #       :compression,       HtsCompression,
-      #       :compression_level, :short,
-      #       :specific,          :pointer
-      #   end
-
-      def struct_layout(*args)
-        Class.new(FFI::Struct) { layout(*args) }
-      end
-    end
-  end
-
-  # Struct that support bit fields.
-  # Currently readonly.
-  class BitStruct < Struct
-    class << self
-      module BitFieldsModule
-        def [](name)
-          bit_fields = self.class.bit_fields_hash_table
-          parent, start, width = bit_fields[name]
-          if parent
-            (super(parent) >> start) & ((1 << width) - 1)
-          else
-            super(name)
-          end
-        end
-      end
-      private_constant :BitFieldsModule
-
-      attr_reader :bit_fields_hash_table
-
-      # @example Bcf1
-      #   class Bcf1 < FFI::BitStruct
-      #     layout \
-      #       :pos,            :hts_pos_t,
-      #       :rlen,           :hts_pos_t,
-      #       :rid,            :int32_t,
-      #       :qual,           :float,
-      #       :_n_info_allele, :uint32_t,
-      #       :_n_fmt_sample,  :uint32_t,
-      #       :shared,         KString,
-      #       :indiv,          KString,
-      #       :d,              BcfDec,
-      #       :max_unpack,     :int,
-      #       :unpacked,       :int,
-      #       :unpack_size,    [:int, 3],
-      #       :errcode,        :int
-      #
-      #     bit_fields :_n_info_allele,
-      #                :n_info,   16,
-      #                :n_allele, 16
-      #
-      #     bit_fields :_n_fmt_sample,
-      #                :n_fmt,    8,
-      #                :n_sample, 24
-      #   end
-
-      def bit_fields(*args)
-        unless instance_variable_defined?(:@bit_fields_hash_table)
-          @bit_fields_hash_table = {}
-          prepend BitFieldsModule
-        end
-
-        parent = args.shift
-        labels = []
-        widths = []
-        args.each_slice(2) do |l, w|
-          labels << l
-          widths << w
-        end
-        starts = widths.inject([0]) do |result, w|
-          result << (result.last + w)
-        end
-        labels.zip(starts, widths).each do |l, s, w|
-          @bit_fields_hash_table[l] = [parent, s, w]
-        end
-      end
-    end
-  end
-end
-
 require_relative "libhts/constants"
 
-# alphabetical order
+# This is alphabetical order.
 require_relative "libhts/bgzf"
 require_relative "libhts/faidx"
 require_relative "libhts/hfile"

data/lib/hts/{tbx.rb → tabix.rb}

@@ -3,8 +3,12 @@
 # Based on hts-python
 # https://github.com/quinlan-lab/hts-python
 
+require_relative "utils/open_method"
+
 module HTS
-  class Tbx
+  class Tabix
+    extend Utils::OpenMethod
+
     def initialize; end
 
     def build; end

data/lib/hts/utils/open_method.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module HTS
+  module Utils
+    module OpenMethod
+      def open(path)
+        object = new(path)
+        if block_given?
+          yield(object)
+          object.close
+        else
+          object
+        end
+      end
+    end
+  end
+end

data/lib/hts/version.rb

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

data/lib/htslib.rb

@@ -40,6 +40,6 @@ module HTS
 end
 
 require_relative "hts/bam"
-require_relative "hts/fai"
-require_relative "hts/tbx"
-require_relative "hts/vcf"
+require_relative "hts/faidx"
+require_relative "hts/tabix"
+require_relative "hts/bcf"