htslib 0.4.2 → 0.6.0

data/lib/hts/bam/base_mod.rb

@@ -12,6 +12,7 @@ module HTS
     class BaseMod
       include Enumerable
 
+      class Error < HTS::Error; end
       class NotParsedError < StandardError; end
 
       attr_reader :record
@@ -133,11 +134,10 @@ module HTS
       # @param auto_parse [Boolean] If true, parse MM/ML lazily on first access
       def initialize(record, auto_parse: true)
         @record = record
-        @state = LibHTS.hts_base_mod_state_alloc
+        @state = Native::BaseModHandle.open(record.__send__(:native_handle))
         @closed = false
         @auto_parse = !!auto_parse
         @parsed = false
-        raise Error, "Failed to allocate hts_base_mod_state" if @state.null?
       end
 
       # Explicitly free the state
@@ -145,8 +145,7 @@ module HTS
       def close
         return if @closed
 
-        # With HtsBaseModState as an AutoPointer, releasing the Ruby object
-        # is sufficient. Avoid manual free to prevent double-free.
+        @state.close
         @state = nil
         @closed = true
       end
@@ -173,7 +172,7 @@ module HTS
       # @return [Integer] Number of modification types found, or -1 on error
       # @raise [Error] If parsing fails
       def parse(flags = 0)
-        ret = LibHTS.bam_parse_basemod2(@record.struct, @state, flags)
+        ret = @state.parse(flags)
         raise Error, "Failed to parse base modifications" if ret < 0
 
         @parsed = true
@@ -188,13 +187,10 @@ module HTS
         # Reset state to ensure deterministic results even after prior iteration
         parsed? ? parse : ensure_parsed!
 
-        mods_ptr = FFI::MemoryPointer.new(LibHTS::HtsBaseMod, max_mods)
+        values = @state.at(position, max_mods)
+        return nil unless values
 
-        ret = LibHTS.bam_mods_at_qpos(@record.struct, position, @state,
-                                      mods_ptr, max_mods)
-        return nil if ret <= 0
-
-        build_position(position, mods_ptr, [ret, max_mods].min)
+        build_position(position, values)
       end
 
       # Array-style access to modifications at a position
@@ -211,36 +207,41 @@ module HTS
       def each_position(max_mods: 10)
         return enum_for(__method__, max_mods: max_mods) unless block_given?
 
-        # Reset state at the start of iteration to allow repeated enumerations
-        parsed? ? parse : ensure_parsed!
-
-        pos_ptr = FFI::MemoryPointer.new(:int)
-        mods_ptr = FFI::MemoryPointer.new(LibHTS::HtsBaseMod, max_mods)
-
-        loop do
-          ret = LibHTS.bam_next_basemod(@record.struct, @state,
-                                        mods_ptr, max_mods, pos_ptr)
-          break if ret <= 0
-
-          position = pos_ptr.read_int
-          yield build_position(position, mods_ptr, [ret, max_mods].min)
+        current_position = nil
+        modifications = []
+        each_raw(max_mods: max_mods) do |position, canonical, modified, strand, qual|
+          if current_position && position != current_position
+            yield Position.new(current_position, modifications)
+            modifications = []
+          end
+          current_position = position
+          modifications << Modification.new(
+            modified_base: modified, canonical_base: canonical,
+            strand: strand, qual: qual
+          )
         end
+        yield Position.new(current_position, modifications) if current_position
+        self
       end
 
       alias each each_position
 
+      # Iterate primitive modification values without Position/Modification
+      # object allocation.
+      def each_raw(max_mods: 10)
+        return enum_for(__method__, max_mods: max_mods) unless block_given?
+
+        parsed? ? parse : ensure_parsed!
+        @state.each_raw(max_mods) { |*values| yield(*values) }
+        self
+      end
+
       # Get list of modification types present in this record
       # @return [Array<Integer>] Array of modification codes (char code or -ChEBI)
       def modification_types
         ensure_parsed!
 
-        ntype_ptr = FFI::MemoryPointer.new(:int)
-        codes_ptr = LibHTS.bam_mods_recorded(@state, ntype_ptr)
-
-        ntype = ntype_ptr.read_int
-        return [] if ntype <= 0 || codes_ptr.null?
-
-        codes_ptr.read_array_of_int(ntype)
+        @state.types
       end
 
       alias recorded_types modification_types
@@ -253,19 +254,7 @@ module HTS
 
         code = code.ord if code.is_a?(String)
 
-        strand_ptr = FFI::MemoryPointer.new(:int)
-        implicit_ptr = FFI::MemoryPointer.new(:int)
-        canonical_ptr = FFI::MemoryPointer.new(:char, 1)
-
-        ret = LibHTS.bam_mods_query_type(@state, code, strand_ptr,
-                                         implicit_ptr, canonical_ptr)
-        return nil if ret < 0
-
-        {
-          canonical: canonical_ptr.read_char.chr,
-          strand: strand_ptr.read_int,
-          implicit: implicit_ptr.read_int != 0
-        }
+        @state.query(code)
       end
 
       # Query information about i-th modification type
@@ -274,21 +263,7 @@ module HTS
       def query_type_at(index)
         ensure_parsed!
 
-        strand_ptr = FFI::MemoryPointer.new(:int)
-        implicit_ptr = FFI::MemoryPointer.new(:int)
-        canonical_ptr = FFI::MemoryPointer.new(:char, 1)
-
-        ret = LibHTS.bam_mods_queryi(@state, index, strand_ptr,
-                                     implicit_ptr, canonical_ptr)
-        return nil if ret < 0
-
-        types = modification_types
-        {
-          code: types[index],
-          canonical: canonical_ptr.read_char.chr,
-          strand: strand_ptr.read_int,
-          implicit: implicit_ptr.read_int != 0
-        }
+        @state.query_at(index)
       end
 
       # Get all modifications as an array
@@ -319,21 +294,11 @@ module HTS
 
       # Build Position object from hts_base_mod array
       # @param position [Integer] Query position
-      # @param mods_ptr [FFI::Pointer] Pointer to array of HtsBaseMod structures
-      # @param n_mods [Integer] Number of modifications
+      # @param values [Array<Array>] Native modification values
       # @return [Position] Position object
-      def build_position(position, mods_ptr, n_mods)
-        modifications = []
-
-        n_mods.times do |i|
-          mod_struct = LibHTS::HtsBaseMod.new(mods_ptr + i * LibHTS::HtsBaseMod.size)
-
-          modifications << Modification.new(
-            modified_base: mod_struct[:modified_base],
-            canonical_base: mod_struct[:canonical_base],
-            strand: mod_struct[:strand],
-            qual: mod_struct[:qual]
-          )
+      def build_position(position, values)
+        modifications = values.map do |canonical, modified, strand, qual|
+          Modification.new(modified_base: modified, canonical_base: canonical, strand:, qual:)
         end
 
         Position.new(position, modifications)

data/lib/hts/bam/cigar.rb

@@ -2,78 +2,32 @@
 
 module HTS
   class Bam < Hts
-    # CIGAR string
     class Cigar
       include Enumerable
 
-      # a uint32_t array (with 32 bits for every CIGAR op: length<<4|operation)
+      OP_CHARS = "MIDNSHP=XB"
       attr_accessor :array
 
-      # Create a new Cigar object from a string.
-      # @param [String] cigar_str
-      # The CIGAR string is converted to a uint32_t array in htslib.
       def self.parse(str)
-        c = FFI::MemoryPointer.new(:pointer)
-        m = FFI::MemoryPointer.new(:size_t)
-        c.write_pointer(FFI::Pointer::NULL)
-        m.write(:size_t, 0)
-        ptr = nil
-        n_cigar = LibHTS.sam_parse_cigar(str, FFI::Pointer::NULL, c, m)
-        raise "sam_parse_cigar failed: #{n_cigar}" if n_cigar.negative?
-
-        ptr = c.read_pointer
-        cigar_array = ptr.null? ? [] : ptr.read_array_of_uint32(n_cigar)
-        obj = new
-        obj.array = cigar_array
-        obj
-      ensure
-        LibHTS.hts_free(ptr) if ptr && !ptr.null?
+        new.tap { |cigar| cigar.array = Native.cigar_parse(str.to_s) }
       end
 
       def initialize(record = nil)
-        if record
-          # The record is used at initialization and is not retained after that.
-          bam1 = record.struct
-          n_cigar = bam1[:core][:n_cigar]
-          @array = LibHTS.bam_get_cigar(bam1).read_array_of_uint32(n_cigar)
-        else
-          @array = []
-        end
+        @array = record ? record.__send__(:native_handle).cigar_values : []
       end
 
-      def to_s
-        map { |op, len| "#{len}#{op}" }.join
-      end
+      def to_s = map { |op, len| "#{len}#{op}" }.join
 
       def each
         return to_enum(__method__) unless block_given?
 
-        @array.each do |c|
-          op =  LibHTS.bam_cigar_opchr(c)
-          len = LibHTS.bam_cigar_oplen(c)
-          yield [op, len]
-        end
+        @array.each { |encoded| yield OP_CHARS[encoded & 15], encoded >> 4 }
       end
 
-      def qlen
-        a = FFI::MemoryPointer.new(:uint32, @array.size)
-        a.write_array_of_uint32(@array)
-        LibHTS.bam_cigar2qlen(@array.size, a)
-      end
-
-      def rlen
-        a = FFI::MemoryPointer.new(:uint32, @array.size)
-        a.write_array_of_uint32(@array)
-        LibHTS.bam_cigar2rlen(@array.size, a)
-      end
-
-      def ==(other)
-        other.is_a?(Cigar) && (@array == other.array)
-      end
-
-      def eql?(other)
-        other.is_a?(Cigar) && @array.eql?(other.array)
-      end
+      def qlen = Native.cigar_qlen(@array)
+      def rlen = Native.cigar_rlen(@array)
+      def ==(other) = other.is_a?(Cigar) && @array == other.array
+      def eql?(other) = other.is_a?(Cigar) && @array.eql?(other.array)
     end
   end
 end

data/lib/hts/bam/flag.rb

@@ -15,31 +15,28 @@ module HTS
 
       attr_accessor :value
 
-      # BAM_FPAIRED        =    1
-      # BAM_FPROPER_PAIR   =    2
-      # BAM_FUNMAP         =    4
-      # BAM_FMUNMAP        =    8
-      # BAM_FREVERSE       =   16
-      # BAM_FMREVERSE      =   32
-      # BAM_FREAD1         =   64
-      # BAM_FREAD2         =  128
-      # BAM_FSECONDARY     =  256
-      # BAM_FQCFAIL        =  512
-      # BAM_FDUP           = 1024
-      # BAM_FSUPPLEMENTARY = 2048
-
-      TABLE = { paired?: LibHTS::BAM_FPAIRED,
-                proper_pair?: LibHTS::BAM_FPROPER_PAIR,
-                unmapped?: LibHTS::BAM_FUNMAP,
-                mate_unmapped?: LibHTS::BAM_FMUNMAP,
-                reverse?: LibHTS::BAM_FREVERSE,
-                mate_reverse?: LibHTS::BAM_FMREVERSE,
-                read1?: LibHTS::BAM_FREAD1,
-                read2?: LibHTS::BAM_FREAD2,
-                secondary?: LibHTS::BAM_FSECONDARY,
-                qcfail?: LibHTS::BAM_FQCFAIL,
-                duplicate?: LibHTS::BAM_FDUP,
-                supplementary?: LibHTS::BAM_FSUPPLEMENTARY }.freeze
+      PAIRED = 1
+      PROPER_PAIR = 2
+      UNMAPPED = 4
+      MATE_UNMAPPED = 8
+      REVERSE = 16
+      MATE_REVERSE = 32
+      READ1 = 64
+      READ2 = 128
+      SECONDARY = 256
+      QCFAIL = 512
+      DUPLICATE = 1024
+      SUPPLEMENTARY = 2048
+
+      UNMAP = UNMAPPED
+      MUNMAP = MATE_UNMAPPED
+      DUP = DUPLICATE
+
+      TABLE = { paired?: PAIRED, proper_pair?: PROPER_PAIR, unmapped?: UNMAPPED,
+                mate_unmapped?: MATE_UNMAPPED, reverse?: REVERSE,
+                mate_reverse?: MATE_REVERSE, read1?: READ1, read2?: READ2,
+                secondary?: SECONDARY, qcfail?: QCFAIL, duplicate?: DUPLICATE,
+                supplementary?: SUPPLEMENTARY }.freeze
 
       # @!macro [attach] generate_flag_methods
       #   @!method $1
@@ -81,9 +78,7 @@ module HTS
       end
 
       def ~
-        # FIXME: Only 12bits are used for flags
-        # The result is different from the Crystal version.
-        self.class.new(~@value)
+        self.class.new((~@value) & 0x0fff)
       end
 
       def <<(f)
@@ -99,8 +94,7 @@ module HTS
       end
 
       def to_s
-        LibHTS.bam_flag2str(@value)
-        # "0x#{format('%x', @value)}\t#{@value}\t#{LibHTS.bam_flag2str(@value)}"
+        Native.bam_flag_string(@value)
       end
     end
   end

data/lib/hts/bam/header.rb

@@ -40,17 +40,15 @@ module HTS
       }.freeze
 
       def self.parse(text)
-        new(LibHTS.sam_hdr_parse(text.size, text))
+        new(Native::SamHeaderHandle.parse(text))
       end
 
       def initialize(arg = nil)
         case arg
-        when LibHTS::HtsFile
-          @sam_hdr = LibHTS.sam_hdr_read(arg)
-        when LibHTS::SamHdr
-          @sam_hdr = arg
+        when Native::SamHeaderHandle
+          @native = arg
         when nil
-          @sam_hdr = LibHTS.sam_hdr_init
+          @native = Native::SamHeaderHandle.create
         else
           raise TypeError, "Invalid argument"
         end
@@ -58,25 +56,16 @@ module HTS
         yield self if block_given?
       end
 
-      def struct
-        @sam_hdr
-      end
-
-      def to_ptr
-        @sam_hdr.to_ptr
-      end
-
       def targets
         Array.new(target_count) do |i|
-          name = LibHTS.sam_hdr_tid2name(@sam_hdr, i)
-          len = LibHTS.sam_hdr_tid2len(@sam_hdr, i)
+          name = @native.target_name(i)
+          len = @native.target_length(i)
           { name:, len: }
         end
       end
 
       def target_count
-        # FIXME: sam_hdr_nref
-        @sam_hdr[:n_targets]
+        @native.target_count
       end
 
       def target_name(tid)
@@ -85,13 +74,13 @@ module HTS
 
       def target_names
         Array.new(target_count) do |i|
-          LibHTS.sam_hdr_tid2name(@sam_hdr, i)
+          @native.target_name(i)
         end
       end
 
       def target_len
         Array.new(target_count) do |i|
-          LibHTS.sam_hdr_tid2len(@sam_hdr, i)
+          @native.target_length(i)
         end
       end
 
@@ -118,68 +107,50 @@ module HTS
 
       # experimental
       def find_line(type, key, value)
-        ks = LibHTS::KString.new
-        begin
-          r = LibHTS.sam_hdr_find_line_id(@sam_hdr, type, key, value, ks)
-          r == 0 ? ks.read_string_copy : nil
-        ensure
-          ks.free_buffer
-        end
+        @native.find_line(type, key, value)
       end
 
       def find_tag(type, id_key, id_value, key)
-        ks = LibHTS::KString.new
-        begin
-          r = LibHTS.sam_hdr_find_tag_id(@sam_hdr, type, id_key, id_value, key, ks)
-          r == 0 ? ks.read_string_copy : nil
-        ensure
-          ks.free_buffer
-        end
+        @native.find_tag(type, id_key, id_value, key)
       end
 
       # experimental
       def find_line_at(type, pos)
-        ks = LibHTS::KString.new
-        begin
-          r = LibHTS.sam_hdr_find_line_pos(@sam_hdr, type, pos, ks)
-          r == 0 ? ks.read_string_copy : nil
-        ensure
-          ks.free_buffer
-        end
+        @native.find_line_at(type, pos)
       end
 
       # experimental
       def remove_line(type, key, value)
-        LibHTS.sam_hdr_remove_line_id(@sam_hdr, type, key, value)
+        @native.remove_line(type, key, value)
       end
 
       # experimental
       def remove_line_at(type, pos)
-        LibHTS.sam_hdr_remove_line_pos(@sam_hdr, type, pos)
+        @native.remove_line_at(type, pos)
       end
 
       def delete_line(type, key = nil, value = nil)
-        LibHTS.sam_hdr_remove_line_id(@sam_hdr, type, key, value).zero?
+        @native.remove_line(type, key, value).zero?
       end
 
       def delete_tag(type, id_key, id_value, key)
-        LibHTS.sam_hdr_remove_tag_id(@sam_hdr, type, id_key, id_value, key) == 1
+        @native.remove_tag(type, id_key, id_value, key) == 1
       end
 
       def count_lines(type)
-        LibHTS.sam_hdr_count_lines(@sam_hdr, type)
+        @native.count_lines(type)
       end
 
       def line_index(type, key)
-        LibHTS.sam_hdr_line_index(@sam_hdr, type, key)
+        @native.line_index(type, key)
       end
 
       def line_name(type, pos)
-        LibHTS.sam_hdr_line_name(@sam_hdr, type, pos)
+        @native.line_name(type, pos)
       end
 
       def to_s
-        LibHTS.sam_hdr_str(@sam_hdr)
+        @native.to_s
       end
 
       # experimental
@@ -241,7 +212,7 @@ module HTS
       #   header.add_pg("samtools", VN: "1.15", PP: "bwa")
       def add_pg(program_name, **options)
         line = build_pg_line(program_name.to_s, options)
-        result = LibHTS.sam_hdr_add_lines(@sam_hdr, line, line.bytesize)
+        result = @native.add_lines(line)
         raise "Failed to add @PG line" if result < 0
 
         self
@@ -418,26 +389,28 @@ module HTS
       end
 
       def name2tid(name)
-        LibHTS.sam_hdr_name2tid(@sam_hdr, name)
+        @native.name2tid(name)
       end
 
       def tid2name(tid)
-        LibHTS.sam_hdr_tid2name(@sam_hdr, tid)
+        @native.target_name(tid)
       end
 
       def add_lines(str)
-        LibHTS.sam_hdr_add_lines(@sam_hdr, str, 0)
+        @native.add_lines(str)
       end
 
       def add_line(*args)
         type = args.shift
-        args = args.flat_map { |arg| [:string, arg] }
-        LibHTS.sam_hdr_add_line(@sam_hdr, type, *args, :pointer, FFI::Pointer::NULL)
+        pairs = args.each_slice(2).map { |key, value| "#{key}:#{value}" }
+        @native.add_lines("@#{type}\t#{pairs.join("\t")}\n")
       end
 
       def initialize_copy(orig)
-        @sam_hdr = LibHTS.sam_hdr_dup(orig.struct)
+        @native = orig.__send__(:native_handle).duplicate
       end
+
+      def native_handle = @native
     end
   end
 end