bio-samtools 0.2.0

data/lib/bio/db/sam/bam.rb

@@ -0,0 +1,210 @@
+# require 'rubygems'
+# require'ffi'
+# require 'bio/db/sam/faidx'
+# require 'bio/db/sam/sam'
+module Bio
+  class DB
+    module SAM
+      module Tools
+        extend FFI::Library
+        
+        #ffi_lib "#{File.join(File.expand_path(File.dirname(__FILE__)),'external','libbam.dylib')}"
+        ffi_lib Bio::DB::SAM::Library.filename
+
+        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_OFDEC = 0
+        BAM_OFHEX = 1
+        BAM_OFSTR = 2
+        BAM_DEF_MASK = (4|256|512|1024)
+        BAM_CIGAR_SHIFT = 4
+        BAM_CIGAR_MASK = ((1 << 4) -1)
+        BAM_CMATCH = 0
+        BAM_CINS = 1
+        BAM_CDEL = 2
+        BAM_CREF_SKIP = 3
+        BAM_CSOFT_CLIP = 4
+        BAM_CHARD_CLIP = 5
+        BAM_CPAD = 6
+        class Bam1CoreT < FFI::Struct
+          #uint32_t bin:16, qual:8, l_qname:8;
+        	#uint32_t flag:16, n_cigar:16;
+          layout(
+          :tid, :int32_t,
+          :pos, :int32_t,
+          :bin, :uint16,
+          :qual, :uint8,
+          :l_qname, :uint8,
+          :flag, :uint16,
+          :n_cigar, :uint16,
+          :l_qseq, :int32_t,
+          :mtid, :int32_t,
+          :mpos, :int32_t,
+          :isize, :int32_t
+          )
+        end
+        class Bam1T < FFI::Struct
+          layout(
+          :core, Bam1CoreT,
+          :l_aux, :int,
+          :data_len, :int,
+          :m_data, :int,
+          :data, :pointer
+          )
+          def qname
+            #bam1_qname(b) ((char*)((b)->data))
+            data = self[:data]
+            data.read_string() 
+          end
+          
+    
+          Bam_NT16_Rev_Table = "=ACMGRSVTWYHKDBN"
+        end
+        
+
+        
+        
+        attach_function :sam_open, [ :string ], :pointer
+        attach_function :sam_close, [ :pointer ], :void
+        attach_function :sam_read1, [ :pointer, :pointer, :pointer ], :int
+        attach_function :sam_header_read2, [ :string ], :pointer
+        attach_function :sam_header_read, [ :pointer ], :pointer
+        attach_function :sam_header_parse, [ :pointer ], :int
+        #attach_function :sam_header_parse_rg, [ :pointer ], :int This is declared in the .h file, but is not implemented
+        #attach_function :bam_strmap_put, [ :pointer, :string, :string ], :int
+        #attach_function :bam_strmap_get, [ :pointer, :string ], :string
+        #attach_function :bam_strmap_dup, [ :pointer ], :pointer
+        #attach_function :bam_strmap_init, [  ], :pointer
+        #attach_function :bam_strmap_destroy, [ :pointer ], :void
+        attach_function :bam_header_init, [  ], :pointer
+        attach_function :bam_header_destroy, [ :pointer ], :void
+        attach_function :bam_header_read, [ :pointer ], :pointer
+        attach_function :bam_header_write, [ :pointer, :pointer ], :int
+        attach_function :bam_read1, [ :pointer, :pointer ], :int
+        attach_function :bam_write1_core, [ :pointer, :pointer, :int, :pointer ], :int
+        attach_function :bam_write1, [ :pointer, :pointer ], :int
+        attach_function :bam_format1, [ :pointer, :pointer ], :string
+        attach_function :bam_format1_core, [ :pointer, :pointer, :int ], :string
+        attach_function :bam_get_library, [ :pointer, :pointer ], :string
+        class BamPileup1T < FFI::Struct
+          layout(
+          :b, :pointer,
+          :qpos, :int32_t,
+          :indel, :int,
+          :level, :int,
+          :is_del, :uint32,
+          :is_head, :uint32,
+          :is_tail, :uint32
+          )
+        end
+        attach_function :bam_plbuf_set_mask, [ :pointer, :int ], :void
+        callback :bam_pileup_f, [ :uint32, :uint32, :int, :pointer, :pointer ], :int
+        attach_function :bam_plbuf_reset, [ :pointer ], :void
+        attach_function :bam_plbuf_init, [ :bam_pileup_f, :pointer ], :pointer
+        attach_function :bam_plbuf_destroy, [ :pointer ], :void
+        attach_function :bam_plbuf_push, [ :pointer, :pointer ], :int
+        attach_function :bam_pileup_file, [ :pointer, :int, :bam_pileup_f, :pointer ], :int
+        attach_function :bam_lplbuf_reset, [ :pointer ], :void
+        attach_function :bam_lplbuf_init, [ :bam_pileup_f, :pointer ], :pointer
+        attach_function :bam_lplbuf_destroy, [ :pointer ], :void
+        attach_function :bam_lplbuf_push, [ :pointer, :pointer ], :int
+        attach_function :bam_index_build, [ :string ], :int
+        attach_function :bam_index_load, [ :string ], :pointer
+        attach_function :bam_index_destroy, [ :pointer ], :void
+        
+        #The function for fetching stuff
+        #typedef int ( *bam_fetch_f)(
+        #    const bam1_t *b,
+        #    void *data);
+        callback(:bam_fetch_f, [ :pointer, :pointer ], :int)
+        attach_function :bam_fetch, [ :pointer, :pointer, :int, :int, :int, :pointer, :bam_fetch_f ], :int
+        attach_function :bam_parse_region, [ :pointer, :pointer, :pointer, :pointer, :pointer ], :int
+
+        #The second parameter must be only 2 characters long
+        attach_function :bam_aux_get, [ :pointer, :string], :pointer
+        attach_function :bam_aux2i, [ :pointer ], :int32_t
+        attach_function :bam_aux2f, [ :pointer ], :float
+        attach_function :bam_aux2d, [ :pointer ], :double
+        attach_function :bam_aux2A, [ :pointer ], :char
+        attach_function :bam_aux2Z, [ :pointer ], :string
+        attach_function :bam_aux_del, [ :pointer, :pointer ], :int
+        #The second parameter must be only 2 characters long
+        attach_function :bam_aux_append, [ :pointer,  :string, :char, :int, :pointer ], :void
+        #The second parameter must be only 2 characters long
+        attach_function :bam_aux_get_core, [ :pointer,:string ], :pointer
+        attach_function :bam_calend, [ :pointer, :pointer ], :uint32
+        attach_function :bam_cigar2qlen, [ :pointer, :pointer ], :int32_t
+
+        #FIXME: if we see that we need this function, implement it on ruby, seems like FFI is having problems with
+        #te static inline.
+        #attach_function :bam_reg2bin, [ :uint32, :uint32 ], :int
+        #FIXME: if we see that we need this function, implement it on ruby, seems like FFI is having problems with
+        #te static inline.
+        #attach_function :bam_copy1, [ :pointer, :pointer ], :pointer
+        #FIXME: if we see that we need this function, implement it on ruby, seems like FFI is having problems with
+        #te static inline.
+        #attach_function :bam_dup1, [ :pointer ], :pointer
+        
+        
+        #bam sort
+          # @abstract Sort an unsorted BAM file based on the chromosome order
+          # and the leftmost position of an alignment
+          # 
+          # @param  is_by_qname whether to sort by query name
+          # @param  fn       name of the file to be sorted
+          # @param  prefix   prefix of the output and the temporary files; upon
+          #                              sucessess, prefix.bam will be written.
+          # @param  max_mem  approxiate maximum memory (very inaccurate)
+          # 
+          # @discussion It may create multiple temporary subalignment files
+          # and then merge them by calling bam_merge_core(). This function is
+          # NOT thread safe.
+        attach_function :bam_sort_core, [:int, :string, :string, :int], :void
+        def self.bam_sort(bam_filename, bam_output_prefix)
+          is_by_name = 0
+          max_mem = 500000000
+          bam_sort_core(is_by_name, bam_filename, bam_output_prefix, max_mem)
+        end
+
+          # @abstract    Merge multiple sorted BAM.
+          # @param  is_by_qname whether to sort by query name
+          # @param  out  output BAM file name
+          # @param  headers  name of SAM file from which to copy '@' header lines,
+          #                  or NULL to copy them from the first file to be merged
+          # @param  n    number of files to be merged
+          # @param  fn   names of files to be merged
+          # 
+          # @discussion Padding information may NOT correctly maintained. This
+          # function is NOT thread safe.
+          # int bam_merge_core(int by_qname, const char *out, const char *headers, int n, char * const *fn,
+          #           int flag, const char *reg)
+
+          # attach_function :bam_merge_core, [:int, :string, :string, :int, :pointer, :int, :string], :int
+          # def self.bam_merge(bam_output_file_name, bam_array_input_file_names, rg)
+          #   is_by_qname = 0
+          #   headers = ""
+          #   flag = 0
+          #   ary = bam_array_input_file_names.map do |filename|
+          #     FFI::MemoryPointer.from_string(filename)
+          #   end
+          #   ary << nil
+          #   fns=FFI::MemoryPointer.new :pointer, ary.size
+          #   ary.each_with_index do |p_filename, idx|
+          #     fns[idx].put_pointer(0, p_filename)
+          #   end
+          #   
+          #   bam_merge_core(is_by_qname, bam_output_file_name, headers, bam_array_input_file_names.size, fns, flag, rg)
+          # end        
+      end
+    end
+  end
+end

data/lib/bio/db/sam/external/COPYING

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2008-2009 Genome Research Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/lib/bio/db/sam/external/VERSION

@@ -0,0 +1 @@
+0.1.16

data/lib/bio/db/sam/faidx.rb

@@ -0,0 +1,21 @@
+#require 'rubygems'
+#require'ffi'
+#require 'bio/db/sam/bam'
+module Bio
+  class DB
+    module SAM
+      module Tools
+        extend FFI::Library
+        #ffi_lib "#{File.join(File.expand_path(File.dirname(__FILE__)),'external','libbam.dylib')}"
+        ffi_lib Bio::DB::SAM::Library.filename
+
+        attach_function :fai_build, [ :string ], :int
+        attach_function :fai_destroy, [ :pointer ], :void
+        attach_function :fai_load, [ :string ], :pointer
+        attach_function :fai_fetch, [ :pointer, :string, :pointer ], :string
+        attach_function :faidx_fetch_nseq, [ :pointer ], :int
+        attach_function :faidx_fetch_seq, [ :pointer, :string, :int, :int, :pointer ], :string
+      end
+    end
+  end
+end

data/lib/bio/db/sam/library.rb

@@ -0,0 +1,25 @@
+module Bio
+  class DB
+    module SAM
+      module Library
+        #IMPORTANT NOTE: Windows library is missing in this distribution
+
+        # Return the path with the file name of the library for the specific operating system
+        def filename
+          #TODO refactor this piece of code in all the files
+          lib_os = case RUBY_PLATFORM
+          when /linux/
+            'so.1'
+          when /darwin/
+            '1.dylib'
+          when /windows/
+            'dll'  
+          end
+
+          File.join(File.expand_path(File.dirname(__FILE__)),'external',"libbam.#{lib_os}")
+        end #filename
+        module_function :filename
+      end #Library
+    end #Sam
+  end #DB
+end #Bio

data/lib/bio/db/sam/sam.rb

@@ -0,0 +1,84 @@
+#
+#  sam.rb
+#  
+#
+#  Created by Ricardo Ramirez on 3/25/10.
+#
+# require 'rubygems'
+# require'ffi'
+# require 'bio/db/sam/bam'
+module Bio
+  class DB
+    module SAM
+      module Tools
+        extend FFI::Library
+        
+#        ffi_lib "#{File.join(File.expand_path(File.dirname(__FILE__)),'external','libbam.#{lib_os}')}"
+         ffi_lib Bio::DB::SAM::Library.filename
+
+#        typedef struct {
+#        	int32_t n_targets;
+#        	char **target_name;
+#        	uint32_t *target_len;
+#        	void *dict, *hash, *rg2lib;
+#        	int l_text;
+#        	char *text;
+#        } bam_header_t;
+        class BamHeaderT < FFI::Struct
+          layout(
+          :n_targets, :int32_t,
+          :target_name, :pointer,
+          :target_len, :pointer,
+          :dict, :pointer,
+          :hash, :pointer,
+          :rg2lib, :pointer,
+          :l_text, :int,
+          :text, :pointer
+          )
+          def text=(str)
+            @text = FFI::MemoryPointer.from_string(str)
+            self[:text] = @text
+          end
+          def text
+            @text.get_string(0)
+          end
+
+        end
+        
+        class SamfileTX < FFI::Union
+          layout(
+          :tamr, :pointer, #Text file, read.
+          :bam,  :pointer, #bamFile,
+          :tamw, :pointer #Text file, write. 
+          )
+        end
+#        typedef struct {
+#        	int type;
+#        	union {
+#        		tamFile tamr;
+#        		bamFile bam;
+#        		FILE *tamw;
+#        	} x;
+#        	bam_header_t *header;
+#        } samfile_t;
+        class SamfileT < FFI::Struct
+          layout(
+          :type, :int,          
+          :x, SamfileTX,
+          :header, :pointer
+          #:header, BamHeaderT
+          )
+        end
+        
+        
+
+        attach_function :samclose, [ :pointer ], :void
+        attach_function :samread, [ :pointer, :pointer ], :int
+        attach_function :samopen, [ :string, :string, :pointer ], :pointer
+        attach_function :samwrite, [ :pointer, :pointer ], :int
+        attach_function :sampileup, [ :pointer, :int, :bam_pileup_f, :pointer ], :int
+        attach_function :samfaipath, [ :string ], :string
+      end
+    end
+  end
+end

data/test/basictest.rb

@@ -0,0 +1,308 @@
+$: << File.expand_path(File.dirname(__FILE__) + '/../lib')
+$: << File.expand_path('.')
+require "test/unit"
+require "bio/db/sam"
+require "bio/db/sam/sam"
+
+
+class TestBioDbSam < Test::Unit::TestCase
+
+  #Set up the paths
+  def setup
+    @test_folder                = "test/samples/small"
+    @testTAMFile                = @test_folder + "/test.tam"
+    @testBAMFile                = @test_folder + "/testu.bam"
+    @testReference              = @test_folder + "/test_chr.fasta"
+    
+  end
+  
+  #Removing the index files
+  def teardown
+    begin
+      File.delete(@testReference + ".fai")
+      p "deleted: " + @testReference + ".fai "
+    rescue
+    end
+    begin
+      File.delete(@testBAMFile + ".fai")
+      p "deleted: " + @testBAMFile + ".bai "
+    rescue
+    end
+  end
+
+  def default_test
+    puts $LOAD_PATH
+    assert(true, "Unit test test")
+  end
+
+  def test_openSAMFile
+    bamfile                      = Bio::DB::SAM::Tools.samopen(@testTAMFile,"r",nil)
+    Bio::DB::SAM::Tools.samclose(bamfile)
+    assert(true, "file open and closed")
+  end
+
+  def test_new_class_empty
+    begin
+      bam                        = Bio::DB::Sam.new({})
+      assert(false, "Should fail while opening without parameters")
+    rescue Bio::DB::SAMException => e
+      puts e.message
+      assert(true, e.message)
+    end
+  end
+
+  def test_new_class_empty_invalid_path
+    begin
+      sam                        = Bio::DB::Sam.new({:bam=>"INVALID"})
+      sam.open
+      sam.close
+      assert(false, "Should fail with an invalid path")
+    rescue Bio::DB::SAMException => e
+      puts e.message
+      assert(true, e.message)
+    end
+  end
+
+  def test_class_text_read_no_faidx
+    sam                          = Bio::DB::Sam.new({:tam=>@testTAMFile})
+    sam.open
+    sam.close
+    assert(true, "file open and closed with the class")
+  end
+
+  def test_class_text_read_no_close
+
+    fam                          = Bio::DB::Sam.new({:tam=>@testTAMFile})
+    fam.open
+    fam                          = nil   
+    ObjectSpace.garbage_collect
+
+    assert(true, "file openend but not closed")
+  end
+
+  def test_class_binary_read_no_close
+
+    Bio::DB::Sam.new({:bam=>@testBAMFile}).open
+    ObjectSpace.garbage_collect
+    assert(true, "BINARY file openend but not closed")  
+  end
+
+  def test_read_coverage
+     sam       = Bio::DB::Sam.new({:bam=>@testBAMFile, :fasta=>@testReference})
+     sam.open
+  	File.open( @test_folder +"/ids2.txt", "r") do |file|
+  	  puts "file opened"
+  	  file.each_line{|line|
+        fetching = line.split(' ')[0]
+        puts "fetching: " + fetching
+  	    sam.load_reference
+    	  seq = sam.fetch_reference(fetching, 0, 16000)
+  #	  puts seq 
+  #	  puts seq.length
+  	  als = sam.fetch(fetching, 0, seq.length) 
+     #      p als
+  	  if als.length() > 0 then
+  	       p fetching
+                p als
+  	    end
+           }
+
+  	end
+    sam.close
+   assert(true, "Finish")
+  end
+#  def test_read_TAM_as_BAM
+#    begin
+#      sam                          = Bio::DB::Sam.new({:bam=>@testTAMFile})
+#      sam.open
+#      sam.close
+#      assert(false, "Should raise an exception for reading a BAM as TAM") 
+#    rescue Bio::DB::SAMException => e
+#      assert(true, "Properly handled")
+#    end 
+#  end
+
+# def test_read_BAM_as_TAM
+#    begin
+#      sam                          = Bio::DB::Sam.new({:tam=>@testBAMFile})
+#      sam.open
+#      sam.close
+#      assert(false, "Should raise an exception for reading a BAM as TAM") 
+#    rescue Bio::DB::SAMException => e
+#      assert(true, "Properly handled")
+#    end 
+#  end
+
+  def test_bam_load_index
+    sam       = Bio::DB::Sam.new({:bam=>@testBAMFile})
+    sam.open
+    index = sam.load_index
+    sam.close
+    assert(true, "BAM index loaded")
+    #  attach_function :bam_index_build, [ :string ], :int
+    #  attach_function :bam_index_load, [ :string ], :pointer
+    #  attach_function :bam_index_destroy, [ :pointer ], :void
+  end
+
+  def test_tam_load_index
+    begin
+      sam       = Bio::DB::Sam.new({:tam=>@testTAMFile})
+      sam.open
+      sam.load_index
+      sam.close
+      assert(false, "TAM index loaded")
+    rescue Bio::DB::SAMException => e
+      assert(true, "Unable to load an index for a TAM file")
+    end
+  end
+
+  def test_read_segment
+    sam       = Bio::DB::Sam.new({:bam=>@testBAMFile})
+    sam.open
+    als = sam.fetch("chr_1", 0, 500)
+    p als 
+    sam.close
+    assert(true, "Seems it ran the query")
+    #node_7263       238     60 has 550+, query from 0 to 500, something shall come.... 
+  end
+
+  def test_read_invalid_reference
+    sam       = Bio::DB::Sam.new({:bam=>@testBAMFile})
+    sam.open
+    begin
+      als = sam.fetch("Chr1", 0, 500)
+      p als 
+      sam.close
+      assert(false, "Seems it ran the query")
+    rescue Bio::DB::SAMException => e
+      p e
+      assert(true, "Exception generated and catched")
+    end
+  end
+
+  def test_read_invalid_reference_start_coordinate
+    sam       = Bio::DB::Sam.new({:bam=>@testBAMFile})
+    sam.open
+    begin
+      als = sam.fetch("chr", -1, 500)
+      p als 
+      sam.close
+      assert(false, "Seems it ran the query")
+    rescue Bio::DB::SAMException => e
+      p e
+      assert(true, "Exception generated and catched")
+    end
+  end
+
+  def test_read_invalid_reference_end_coordinate
+    sam       = Bio::DB::Sam.new({:bam=>@testBAMFile})
+    sam.open
+    begin
+      als = sam.fetch("chr", 0, 50000)
+      p als 
+      sam.close
+      assert(false, "Seems it ran the query")
+    rescue  Bio::DB::SAMException => e
+      p e
+      assert(true, "Exception generated and catched")
+    end
+  end
+  
+  def test_read_invalid_reference_swaped_coordinates
+    sam       = Bio::DB::Sam.new({:bam=>@testBAMFile})
+    sam.open
+    begin
+      als = sam.fetch("chr", 500, 0)
+      p als 
+      sam.close
+      assert(false, "Seems it ran the query")
+    rescue  Bio::DB::SAMException => e
+      p e
+      assert(true, "Exception generated and catched")
+    end
+  end
+
+  def test_fasta_load_index
+    sam = Bio::DB::Sam.new({:fasta=>@testReference})
+    sam.load_reference
+    seq = sam.fetch_reference("chr_1", 0, 500)
+    p seq 
+    sam.close
+    assert(true, "The reference was loaded")
+  end
+  
+  def test_fasta_load_index
+    sam = Bio::DB::Sam.new({:fasta=>@testReference})
+    sam.load_reference
+    begin
+      seq = sam.fetch_reference("chr1", 0, 500)
+      p "Error seq:"+ seq 
+      sam.close
+      assert(false, "The reference was loaded")
+    rescue Bio::DB::SAMException => e
+      p e
+      assert(true,  "The references was not loaded")
+    end
+  end
+  
+  def test_load_feature
+    
+    fs = Feature.find_by_bam("chr_1", 0, 500,@testBAMFile)
+    
+    p fs
+    assert(true, "Loaded as features")
+  end
+  
+  def test_avg_coverage
+    sam = Bio::DB::Sam.new({:fasta=>@testReference, :bam=>@testBAMFile })
+    sam.open
+    cov = sam.average_coverage("chr_1", 60, 30)
+    p "Coverage: " + cov.to_s
+    sam.close
+    assert(true, "Average coverage ran")
+    assert(3 == cov, "The coverage is 3")
+  end
+  
+
+  def test_chromosome_coverage
+    sam = Bio::DB::Sam.new({:fasta=>@testReference, :bam=>@testBAMFile })
+    sam.open
+    covs = sam.chromosome_coverage("chr_1", 0, 60)
+    p "Coverage: "
+    p covs
+    puts "POS\tCOV"
+    covs.each_with_index{ |cov, i| puts "#{i}\t#{cov}" }
+    sam.close
+    assert(true, "Average coverage ran")
+    #assert(3 == cov, "The coverage is 3")
+  end
+
+end
+
+class Feature 
+attr_reader :start, :end, :strand, :sequence, :quality
+
+def initialize(a={})
+  p a
+  @start = a[:start]
+  @end = a[:enf]
+  @strand = a[:strand]
+  @sequence = a[:sequence]
+  @quality = a[:quality]
+end
+
+def self.find_by_bam(reference,start,stop,bam_file_path)
+  
+  sam = Bio::DB::Sam.new({:bam=>bam_file_path})
+  features = []
+  sam.open
+  
+  fetchAlignment = Proc.new do |a|
+    a.query_strand ? strand = '+'  : strand = '-'
+    features << Feature.new({:start=>a.pos,:end=>a.calend,:strand=>strand,:sequence=>a.seq,:quality=>a.qual})
+  end
+  sam.fetch_with_function(reference, start, stop, fetchAlignment)
+  sam.close
+  features
+end
+end