htslib 0.0.0.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c4cf91042ebfca63fa53176e80b71d93e0a3deb8938edbeccb306ac66b2f4d9b
+  data.tar.gz: 33ef01ac381c684c1da7ef03e12043164c70e58849e03c97d7fd9f89f19382c7
+SHA512:
+  metadata.gz: a0334a54d5e96243652ded099b6d07352f6a145e01dbb7853a0a00f1e040ac5175f0f95c4262600bb4e76ea282e1d283ff12b1b44e54f8d75f1a206a6f5ca319
+  data.tar.gz: 006b404fa6a9a05a316bd214bf4a3b737d46a8cc6e9b3fd05772e3547b03960e254bc3aad5d04d26ce741709e8926e6d57eca4a396b345cfe5165646d28a6a11

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 kojix2
+
+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/README.md

@@ -0,0 +1,45 @@
+# HTSlib
+
+![CI](https://github.com/kojix2/ruby-htslib/workflows/CI/badge.svg?branch=master)
+
+:apple: Feel free to fork it out if you can develop it! 
+
+:bowtie: Just a prototype. 
+
+## Installation
+
+```sh
+gem install htslib
+```
+
+Set environment variable HTSLIBDIR. 
+
+```sh
+export HTSLIBDIR="/your/path/to/htslib"
+```
+
+## Requirements
+
+* [htslib](https://github.com/samtools/htslib)
+
+## Usage
+
+```ruby
+require 'htslib'
+
+a = HTS::FFI.hts_open("a.bam", "r")
+b = HTS::FFI.hts_get_format(a)
+p b[:category]
+p b[:format]
+```
+
+## Development
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/kojix2/ruby-htslib.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/hts/bam.rb

@@ -0,0 +1,85 @@
+# Create a skeleton using hts-python as a reference.
+# https://github.com/quinlan-lab/hts-python
+
+class BamHeader
+  def initialize; end
+
+  def seqs; end
+end
+
+class Cigar
+  def initialize; end
+
+  def to_s; end
+
+  def inspect; end
+end
+
+class Alignment
+  def initialize; end
+
+  def self.rom_sam_str; end
+
+  def tags; end
+
+  def qname; end
+
+  def qname=; end
+
+  def rnext; end
+
+  def pnext; end
+
+  def rname; end
+
+  def strand; end
+
+  def base_qualities; end
+
+  def pos; end
+
+  def pos=; end
+
+  def isize; end
+
+  def mapping_quality; end
+
+  def cigar; end
+
+  def qlen; end
+
+  def rlen; end
+
+  def seqs; end
+
+  def flag_str; end
+
+  def flag; end
+
+  # def eql?
+  # def hash
+
+  def inspect; end
+
+  def to_s; end
+end
+
+class Bam
+  def initialize; end
+
+  def self.header_from_fasta; end
+
+  def inspect; end
+
+  def write; end
+
+  def close; end
+
+  def flush; end
+
+  def to_s; end
+
+  def each; end
+
+  # def call
+end

data/lib/hts/fai.rb

@@ -0,0 +1,14 @@
+# Create a skeleton using hts-python as a reference.
+# https://github.com/quinlan-lab/hts-python
+
+class Fai
+  def initialize; end
+
+  # def call
+
+  def nseqs; end
+
+  def include?; end
+
+  # __iter__
+end

data/lib/hts/ffi.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module HTS
+  module FFI
+    extend ::FFI::Library
+
+    begin
+      ffi_lib HTS.ffi_lib
+    rescue LoadError => e
+      raise LoadError, "Could not find HTSlib.#{FFI::Platform::LIBSUFFIX}"
+    end
+
+    def self.attach_function(*)
+      super
+    rescue ::FFI::NotFoundError => e
+      warn e.message
+    end
+  end
+end
+
+require_relative 'ffi/struct'
+require_relative 'ffi_constants'
+
+# alphabetical order
+require_relative 'ffi/bgzf'
+require_relative 'ffi/faidx'
+require_relative 'ffi/hfile'
+require_relative 'ffi/hts'
+require_relative 'ffi/sam'
+require_relative 'ffi/kfunc'
+require_relative 'ffi/tbx'

data/lib/hts/ffi/bgzf.rb

@@ -0,0 +1,192 @@
+# BGZF
+module HTS
+  module FFI
+    # Open an existing file descriptor for reading or writing.
+    attach_function \
+      :bgzf_dopen,
+      %i[int string],
+      BGZF.by_ref
+
+    # Open the specified file for reading or writing.
+    attach_function \
+      :bgzf_open,
+      %i[string string],
+      BGZF.by_ref
+
+    # Open an existing hFILE stream for reading or writing.
+    attach_function \
+      :bgzf_hopen,
+      %i[HFILE string],
+      BGZF.by_ref
+
+    # Close the BGZF and free all associated resources.
+    attach_function \
+      :bgzf_close,
+      [:HFILE],
+      :int
+
+    # Read up to _length_ bytes from the file storing into _data_.
+    attach_function \
+      :bgzf_read,
+      %i[HFILE pointer size_t],
+      :ssize_t
+
+    # Write _length_ bytes from _data_ to the file. If no I/O errors occur,
+    # the complete _length_ bytes will be written (or queued for writing).
+    attach_function \
+      :bgzf_write,
+      [BGZF, :pointer, :size_t],
+      :ssize_t
+
+    # Write _length_ bytes from _data_ to the file, the index will be used to
+    # decide the amount of uncompressed data to be writen to each bgzip block.
+    attach_function \
+      :bgzf_block_write,
+      [BGZF, :pointer, :size_t],
+      :ssize_t
+
+    # Returns the next byte in the file without consuming it.
+    attach_function \
+      :bgzf_peek,
+      [BGZF],
+      :int
+
+    # Read up to _length_ bytes directly from the underlying stream without
+    # decompressing.  Bypasses BGZF blocking, so must be used with care in
+    # specialised circumstances only.
+    attach_function \
+      :bgzf_raw_read,
+      [BGZF, :pointer, :size_t],
+      :ssize_t
+
+    # Write _length_ bytes directly to the underlying stream without
+    # compressing.  Bypasses BGZF blocking, so must be used with care
+    # in specialised circumstances only.
+    attach_function \
+      :bgzf_raw_write,
+      [BGZF, :pointer, :size_t],
+      :ssize_t
+
+    # Write the data in the buffer to the file.
+    attach_function \
+      :bgzf_flush,
+      [BGZF],
+      :int
+
+    # Set the file to read from the location specified by _pos_.
+    attach_function \
+      :bgzf_seek,
+      [BGZF, :int64, :int],
+      :int64
+
+    # Check if the BGZF end-of-file (EOF) marker is present
+    attach_function \
+      :bgzf_check_EOF,
+      [BGZF],
+      :int
+
+    # Return the file's compression format
+    attach_function \
+      :bgzf_compression,
+      [BGZF],
+      :int
+
+    # Check if a file is in the BGZF format
+    attach_function \
+      :bgzf_is_bgzf,
+      [:string],
+      :int
+
+    # Set the cache size. Only effective when compiled with -DBGZF_CACHE.
+    attach_function \
+      :bgzf_set_cache_size,
+      [BGZF, :int],
+      :void
+
+    # Flush the file if the remaining buffer size is smaller than _size_
+    attach_function \
+      :bgzf_flush_try,
+      [BGZF, :ssize_t],
+      :int
+
+    # Read one byte from a BGZF file. It is faster than bgzf_read()
+    attach_function \
+      :bgzf_getc,
+      [BGZF],
+      :int
+
+    # Read one line from a BGZF file. It is faster than bgzf_getc()
+    attach_function \
+      :bgzf_getline,
+      [BGZF, :int, Kstring],
+      :int
+
+    # Read the next BGZF block.
+    attach_function \
+      :bgzf_read_block,
+      [BGZF],
+      :int
+
+    # Enable multi-threading (when compiled with -DBGZF_MT) via a shared
+    # thread pool.
+    attach_function \
+      :bgzf_thread_pool,
+      [BGZF, :pointer, :int],
+      :int
+
+    # Enable multi-threading (only effective when the library was compiled
+    # with -DBGZF_MT)
+    attach_function \
+      :bgzf_mt,
+      [BGZF, :int, :int],
+      :int
+
+    # Compress a single BGZF block.
+    attach_function \
+      :bgzf_compress,
+      %i[pointer pointer pointer size_t int],
+      :int
+
+    # Position BGZF at the uncompressed offset
+    attach_function \
+      :bgzf_useek,
+      [BGZF, :off_t, :int],
+      :int
+
+    # Position in uncompressed BGZF
+    attach_function \
+      :bgzf_utell,
+      [BGZF],
+      :off_t
+
+    # Tell BGZF to build index while compressing.
+    attach_function \
+      :bgzf_index_build_init,
+      [BGZF],
+      :int
+
+    # Load BGZF index
+    attach_function \
+      :bgzf_index_load,
+      [BGZF, :string, :string],
+      :int
+
+    # Load BGZF index from an hFILE
+    attach_function \
+      :bgzf_index_load_hfile,
+      [BGZF, :HFILE, :string],
+      :int
+
+    # Save BGZF index
+    attach_function \
+      :bgzf_index_dump,
+      [BGZF, :string, :string],
+      :int
+
+    # Write a BGZF index to an hFILE
+    attach_function \
+      :bgzf_index_dump_hfile,
+      [BGZF, :HFILE, :string],
+      :int
+  end
+end

data/lib/hts/ffi/faidx.rb

@@ -0,0 +1,139 @@
+module HTS
+  module FFI
+    # Build index for a FASTA or FASTQ or bgzip-compressed FASTA or FASTQ file.
+    attach_function \
+      :fai_build3,
+      %i[string string string],
+      :int
+
+    # Build index for a FASTA or FASTQ or bgzip-compressed FASTA or FASTQ file.
+    attach_function \
+      :fai_build,
+      [:string],
+      :int
+
+    # Destroy a faidx_t struct
+    attach_function \
+      :fai_destroy,
+      [Faidx],
+      :void
+
+    # Load FASTA indexes.
+    attach_function \
+      :fai_load3,
+      %i[string string string int],
+      Faidx.by_ref
+
+    # Load index from "fn.fai".
+    attach_function \
+      :fai_load,
+      [:string],
+      Faidx.by_ref
+
+    #  Load FASTA or FASTQ indexes.
+    attach_function \
+      :fai_load3_format,
+      [:string, :string, :string, :int, FaiFormatOptions],
+      Faidx.by_ref
+
+    # Load index from "fn.fai".
+    attach_function \
+      :fai_load_format,
+      [:string, FaiFormatOptions],
+      Faidx.by_ref
+
+    # Fetch the sequence in a region
+    attach_function \
+      :fai_fetch,
+      [Faidx, :string, :pointer],
+      :string
+
+    # Fetch the sequence in a region
+    attach_function \
+      :fai_fetch64,
+      [Faidx, :string, :pointer],
+      :string
+
+    # Fetch the quality string for a region for FASTQ files
+    attach_function \
+      :fai_fetchqual,
+      [Faidx, :string, :pointer],
+      :string
+
+    attach_function \
+      :fai_fetchqual64,
+      [Faidx, :string, :pointer],
+      :string
+
+    # Fetch the number of sequences
+    attach_function \
+      :faidx_fetch_nseq,
+      [Faidx],
+      :int
+
+    # Fetch the sequence in a region
+    attach_function \
+      :faidx_fetch_seq,
+      [Faidx, :string, :int, :int, :pointer],
+      :string
+
+    # Fetch the sequence in a region
+    attach_function \
+      :faidx_fetch_seq64,
+      [Faidx, :string, :int64, :int64, :pointer],
+      :string
+
+    # Fetch the quality string in a region for FASTQ files
+    attach_function \
+      :faidx_fetch_qual,
+      [Faidx, :string, :int, :int, :pointer],
+      :string
+
+    # Fetch the quality string in a region for FASTQ files
+    attach_function \
+      :faidx_fetch_qual64,
+      [Faidx, :string, :int64, :int64, :pointer],
+      :string
+
+    # Query if sequence is present
+    attach_function \
+      :faidx_has_seq,
+      [Faidx, :string],
+      :int
+
+    # Return number of sequences in fai index
+    attach_function \
+      :faidx_nseq,
+      [Faidx],
+      :int
+
+    # Return name of i-th sequence
+    attach_function \
+      :faidx_iseq,
+      [Faidx, :int],
+      :string
+
+    # Return sequence length, -1 if not present
+    attach_function \
+      :faidx_seq_len,
+      [Faidx, :string],
+      :int
+
+    # Parses a region string.
+    attach_function \
+      :fai_parse_region,
+      [Faidx, :string, :pointer, :pointer, :pointer, :int], :string
+
+    # Sets the cache size of the underlying BGZF compressed file
+    attach_function \
+      :fai_set_cache_size,
+      [Faidx, :int],
+      :void
+
+    # Determines the path to the reference index file
+    attach_function \
+      :fai_path,
+      [:string],
+      :string
+  end
+end