htslib 0.0.1 → 0.0.5

data/lib/hts/bcf/format.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# https://github.com/brentp/hts-nim/blob/master/src/hts/vcf.nim
+# This is a port from Nim.
+# TODO: Make it more like Ruby.
+
+module HTS
+  class Bcf
+    class Format
+      def initialize(record)
+        @record = record
+        @p1 = FFI::MemoryPointer.new(:pointer) # FIXME: naming
+      end
+
+      def get(key, type = nil)
+        n = FFI::MemoryPointer.new(:int)
+        p1 = @p1
+        h = @record.bcf.header.struct
+        r = @record.struct
+
+        format_values = proc do |type|
+          ret = LibHTS.bcf_get_format_values(h, r, key, p1, n, type)
+          return nil if ret < 0 # return from method.
+
+          p1.read_pointer
+        end
+
+        case type.to_sym
+        when :int, :int32
+          format_values.call(LibHTS::BCF_HT_INT)
+                       .read_array_of_int32(n.read_int)
+        when :float, :real
+          format_values.call(LibHTS::BCF_HT_REAL)
+                       .read_array_of_float(n.read_int)
+        when :flag
+          format_values.call(LibHTS::BCF_HT_FLAG)
+                       .read_int == 1
+        when :string, :str
+          format_values.call(LibHTS::BCF_HT_STR)
+                       .read_pointer.read_string
+        end
+      end
+
+      def set; end
+
+      # def fields # iterator
+      # end
+
+      def genotypes; end
+    end
+  end
+end

data/lib/hts/bcf/header.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module HTS
+  class Bcf
+    class Header
+      def initialize(h)
+        @h = h
+      end
+
+      def struct
+        @h
+      end
+
+      def to_ptr
+        @h.to_ptr
+      end
+    end
+  end
+end

data/lib/hts/bcf/info.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module HTS
+  class Bcf
+    class Info
+      def initialize(record)
+        @record = record
+      end
+
+      # @note Specify the type. If you don't specify a type, it will still work, but it will be slower.
+      def get(key, type = nil)
+        n = FFI::MemoryPointer.new(:int)
+        p1 = @record.p1
+        h = @record.bcf.header.struct
+        r = @record.struct
+
+        info_values = proc do |type|
+          ret = LibHTS.bcf_get_info_values(h, r, key, p1, n, type)
+          return nil if ret < 0 # return from method.
+
+          p1.read_pointer
+        end
+
+        type ||= info_type_to_string(get_info_type(key))
+
+        case type&.to_sym
+        when :int, :int32
+          info_values.call(LibHTS::BCF_HT_INT)
+                     .read_array_of_int32(n.read_int)
+        when :float, :real
+          info_values.call(LibHTS::BCF_HT_REAL)
+                     .read_array_of_float(n.read_int)
+        when :flag, :bool
+          case ret = LibHTS.bcf_get_info_flag(h, r, key, p1, n)
+          when 1 then true
+          when 0 then false
+          when -1 then nil
+          else
+            raise "Unknown return value from bcf_get_info_flag: #{ret}"
+          end
+        when :string, :str
+          info_values.call(LibHTS::BCF_HT_STR)
+                     .read_string
+        end
+      end
+
+      def fields
+        n_info = @record.struct[:n_info]
+        Array.new(n_info) do |i|
+          fld = LibHTS::BcfInfo.new(
+            @record.struct[:d][:info] +
+            i * LibHTS::BcfInfo.size
+          )
+          {
+            name: LibHTS.bcf_hdr_int2id(
+              @record.bcf.header.struct, LibHTS::BCF_DT_ID, fld[:key]
+            ),
+            n: LibHTS.bcf_hdr_id2number(
+              @record.bcf.header.struct, LibHTS::BCF_HL_INFO, fld[:key]
+            ),
+            vtype: fld[:type], i: fld[:key]
+          }
+        end
+      end
+
+      private
+
+      def get_info_type(key)
+        @record.struct[:n_info].times do |i|
+          fld = LibHTS::BcfInfo.new(
+            @record.struct[:d][:info] +
+            i * LibHTS::BcfInfo.size
+          )
+          id = LibHTS.bcf_hdr_int2id(
+            @record.bcf.header.struct, LibHTS::BCF_DT_ID, fld[:key]
+          )
+          return fld[:type] if id == key
+        end
+      end
+
+      def info_type_to_string(t)
+        case t
+        when 0 then :flag
+        when 1, 2, 3, 4 then :int
+        when 5 then :float
+        when 7 then :string
+        else
+          raise "Unknown info type: #{t}"
+        end
+      end
+    end
+  end
+end

data/lib/hts/bcf/record.rb

@@ -0,0 +1,110 @@
+# 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]
+
+        LibHTS.bcf_hdr_id2name(hdr, rid)
+      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
+        raise "Failed to format record" if LibHTS.vcf_format(@bcf.header.struct, @bcf1, ksr) == -1
+
+        ksr[:s]
+      end
+    end
+  end
+end

data/lib/hts/bcf.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# Based on hts-python
+# https://github.com/quinlan-lab/hts-python
+
+require_relative "bcf/header"
+require_relative "bcf/info"
+require_relative "bcf/format"
+require_relative "bcf/record"
+
+module HTS
+  class Bcf
+    include Enumerable
+
+    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))
+
+      # 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
+      return to_enum(__method__) unless block_given?
+
+      while LibHTS.bcf_read(htf_file, header, bcf1 = LibHTS.bcf_init) != -1
+        record = Record.new(bcf1, self)
+        yield record
+      end
+      self
+    end
+
+    def n_samples
+      LibHTS.bcf_hdr_nsamples(header.struct)
+    end
+  end
+end

data/lib/hts/faidx.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# Based on hts-python
+# https://github.com/quinlan-lab/hts-python
+
+module HTS
+  class Faidx
+    attr_reader :file_path
+
+    class << self
+      alias open new
+    end
+
+    def initialize(file_path)
+      @file_path = File.expand_path(file_path)
+      @fai = LibHTS.fai_load(file_path)
+
+      # IO like API
+      if block_given?
+        begin
+          yield self
+        ensure
+          close
+        end
+      end
+    end
+
+    def close
+      LibHTS.fai_destroy(@fai)
+    end
+
+    # the number of sequences in the index.
+    def size
+      LibHTS.faidx_nseq(@fai)
+    end
+    alias length size
+
+    # return the length of the requested chromosome.
+    def chrom_size(chrom)
+      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)
+      result == -1 ? nil : result
+    end
+    alias chrom_length chrom_size
+
+    # FIXME: naming and syntax
+    def cget; end
+
+    # FIXME: naming and syntax
+    def get; end
+
+    # __iter__
+  end
+end

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_field'
+
+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/{ffi → libhts}/bgzf.rb

@@ -2,7 +2,7 @@
 
 # BGZF
 module HTS
-  module FFI
+  module LibHTS
     # Open an existing file descriptor for reading or writing.
     attach_function \
       :bgzf_dopen,
@@ -120,7 +120,7 @@ module HTS
     # Read one line from a BGZF file. It is faster than bgzf_getc()
     attach_function \
       :bgzf_getline,
-      [BGZF, :int, Kstring],
+      [BGZF, :int, KString],
       :int
 
     # Read the next BGZF block.