libssw 0.0.2 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 182b0d30cdf3d9a93b100b05f96d469d612b09bcfcfd2afc3cb63a4c93501d17
-  data.tar.gz: 99ec370125c707acff3a99664706ce8691f2e66e48d22a49af0362894b2c6b72
+  metadata.gz: 0b67671ac9e959ee7e147bfff872719e6c787a020fb15a9b63e9128aef51d9d3
+  data.tar.gz: 0baec30769ef3e0f9248346dded445d9a4fa1eaafd9b2071b74e9e5deeb7e4be
 SHA512:
-  metadata.gz: 8a49bf4924da5d12310b691f9f9335d96cdce0ef4b82ac1a38aeb6293c92d939cd17e4b0e6e99a4c427a0f4074f94db1cca91ca6c26b76a0551e558371b4aee7
-  data.tar.gz: 5af24c2124cd53f8aa54dc905172eb6f9b3d7c57b33fb87d1884ca2ab1a90acf0cb1f2ca73cb88eecda223e3f723836cca2dbae9cb0c1ac665d097993645ee19
+  metadata.gz: 6fb9b0ad32647d27418b666545f3fe34ffab9e902ddbae0575733695d6101fa26b261dcc5d9066e9b8c9a85bac3e1c2cce6be79b58c63aab7a0896b691561a7e
+  data.tar.gz: 9c3862016d4490e0fce60296acf8fbe129c5f166363c0cdd978862e066819ec8b2a850dc345716750503e15521480e026d2aac0278f0e8db9394505cc98db3ab

data/README.md

@@ -3,11 +3,10 @@
 ![test](https://github.com/kojix2/ruby-libssw/workflows/CI/badge.svg)
 [![Gem Version](https://img.shields.io/gem/v/libssw?color=brightgreen)](https://rubygems.org/gems/libssw)
 [![Docs Latest](https://img.shields.io/badge/docs-latest-blue.svg)](https://rubydoc.info/gems/libssw)
+[![DOI](https://zenodo.org/badge/328163622.svg)](https://zenodo.org/badge/latestdoi/328163622)
 
 :checkered_flag: [libssw](https://github.com/mengyao/Complete-Striped-Smith-Waterman-Library) - fast SIMD parallelized implementation of the Smith-Waterman algorithm - for Ruby
 
-:construction: Under development.
-
 ## Installation
 
 ```ssh
@@ -24,41 +23,42 @@ export LIBSSWDIR=/usr/lib/x86_64-linux-gnu/ # libssw.so
 
 ### Installing from source
 
-When installing from source code using the following steps, the shared library `libssw.so` will be packed in the Ruby gem. In this case, the environment variable LIBSSWDIR is not required. (Only tested on Ubuntu)
+When installing from source code using the following steps, the shared library `libssw.so` or `libssw.dylib` will be packed in the Ruby gem. In this case, the environment variable `LIBSSWDIR` is not required.
 
 ```sh
-git clone --recurse-submodules https://github.com/kojix2/ruby-libssw
-bundle exec rake libssw:compile
+git clone --recursive https://github.com/kojix2/ruby-libssw
+bundle exec rake libssw:build
 bundle exec rake install
 ```
 
+ruby-libssw does not support Windows.
+
 ## Usage
 
 ```ruby
 require 'libssw'
 
-SSW = LibSSW
-
 ref_str  = "AAAAAAAAACGTTAAAAAAAAAA"
-ref_int  = SSW.dna_to_int_array(ref_str) 
+ref_int  = SSW::DNA.to_int_array(ref_str)
 # [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
 
 read_str1 = "ACGTT"
-read_str2 = SSW.dna_complement(read_str1)
-read_int1 = SSW.dna_to_int_array(read_str1)
+read_str2 = SSW::DNA.revcomp(read_str1)
+# "AACGT"
+read_int1 = SSW::DNA.to_int_array(read_str1)
 # [0, 1, 2, 3, 3]
-read_int2 = SSW.dna_to_int_array(read_str2)
+read_int2 = SSW::DNA.to_int_array(read_str2)
 # [0, 0, 1, 2, 3]
 
-mat = SSW.create_scoring_matrix(SSW::DNAElements, 2, -2)
+mat = SSW.create_scoring_matrix(SSW::DNA::Elements, 2, -2)
 # mat = [2, -2, -2, -2,  0,
 #       -2,  2, -2, -2,  0,
 #       -2, -2,  2, -2,  0,
 #       -2, -2, -2,  2,  0,
 #        0,  0,  0,  0,  0]
 
-profile1 = LibSSW.ssw_init(read_int1, mat)
-align1   = LibSSW.ssw_align(profile1, ref_int, 3, 1, 1, 0, 0, 15)
+profile1 = SSW.init(read_int1, mat)
+align1   = SSW.align(profile1, ref_int, 3, 1, 1, 0, 0)
 pp align1.to_h
 # {
 #  :score1       => 10,
@@ -73,8 +73,8 @@ pp align1.to_h
 #  :cigar_string => "5M"
 # }
 
-profile2 = LibSSW.ssw_init(read_int2, mat)
-align2     = LibSSW.ssw_align(profile2, ref_int, 3, 1, 1, 0, 0, 15)
+profile2 = SSW.init(read_int2, mat)
+align2   = SSW.align(profile2, ref_int, 3, 1, 1, 0, 0)
 pp align2.to_h
 # {
 #  :score1       => 10,
@@ -88,25 +88,75 @@ pp align2.to_h
 #  :cigar_len    => 1,
 #  :cigar_string => "5M"
 # }
+
+puts SSW.build_path(read_str1, ref_str, align1)
+# 5M
+# ACGTT
+# |||||
+# ACGTT
 ```
 
+## APIs
+
+See [API Documentation](https://rubydoc.info/gems/libssw).
+
+```markdown
+- SSW module
+
+  - SSW.init
+  - SSW.init_destroy
+  - SSW.align
+  - SSW.align_destroy
+  - SSW.mark_mismatch
+  - SSW.create_scoring_matrix
+  - SSW.build_path
+
+  - Profile class
 
-## Documentation
+    - attributes
+      - read, mat, read_len, n, bias
 
-* [API Documentation](https://rubydoc.info/gems/libssw)
+  - Align class
+
+    - attributes
+      - score1, score2, ref_begin1, ref_end1, read_begin1, read_end1, ref_end2
+        cigar, cigar_len, cigar_string
+
+  - DNA module
+
+    - DNA.to_int_array
+    - DNA.from_int_array
+    - revcomp
+
+  - AASeq module
+
+    - AASeq.to_int_array
+    - AASeq.from_int_array
+
+  - BLOSUM62
+  - BLOSUM50
+```
 
 ## Development
 
 ```sh
-git clone --recurse-submodules https://github.com/kojix2/ruby-libssw
-bundle exec rake libssw:compile
+git clone --recursive https://github.com/kojix2/ruby-libssw
+bundle exec rake libssw:build
 bundle exec rake test
 ```
 
+    Do you need commit rights to my repository?
+    Do you want to get admin rights and take over the project?
+    If so, please feel free to contact me @kojix2.
+
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/kojix2/ruby-libssw.
+- [Report bugs](https://github.com/kojix2/ruby-libssw/issues)
+- Fix bugs and [submit pull requests](https://github.com/kojix2/ruby-libssw/pulls)
+- Write, clarify, or fix documentation
+- English corrections are welcome
+- Suggest or add new features
 
 ## License
 
-* [MIT License](https://opensource.org/licenses/MIT).
+- [MIT License](https://opensource.org/licenses/MIT).

data/lib/libssw.rb

@@ -1,24 +1,19 @@
 # frozen_string_literal: true
 
-require_relative 'libssw/version'
-require_relative 'libssw/BLOSUM50'
-require_relative 'libssw/BLOSUM62'
+require_relative 'ssw/version'
+require_relative 'ssw/BLOSUM50'
+require_relative 'ssw/BLOSUM62'
+require_relative 'ssw/dna'
+require_relative 'ssw/aaseq'
 
-module LibSSW
+module SSW
   class Error < StandardError; end
 
   class << self
     attr_accessor :ffi_lib
   end
 
-  lib_name = case RbConfig::CONFIG['host_os']
-             when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
-               'libssw.dll'   # unconfirmed
-             when /darwin|mac os/
-               'libssw.dylib' # unconfirmed
-             else
-               'libssw.so'
-             end
+  lib_name = "libssw.#{RbConfig::CONFIG['SOEXT']}" # Ruby 2.5 or later
 
   self.ffi_lib = if ENV['LIBSSWDIR'] && !ENV['LIBSSWDIR'].empty?
                    File.expand_path(lib_name, ENV['LIBSSWDIR'])
@@ -26,67 +21,14 @@ module LibSSW
                    File.expand_path("../vendor/#{lib_name}", __dir__)
                  end
 
-  require_relative 'libssw/ffi'
-  require_relative 'libssw/profile'
-  require_relative 'libssw/align'
+  # NOTE: Why not use pkg-config?
+  # APT package is available.
+  # However, it dose not include a .pc file.
+  # Thus pkg-config will not find the shared library.
 
-  AAELEMENTS = ['A', 'R', 'N', 'D', 'C', 'Q', 'E', 'G',
-                'H', 'I', 'L', 'K', 'M', 'F', 'P', 'S',
-                'T', 'W', 'Y', 'V', 'B', 'Z', 'X', '*']
-
-  AA2INT = { 'A' => 0,  'a' => 0,
-             'R' => 1,  'r' => 1,
-             'N' => 2,  'n' => 2,
-             'D' => 3,  'd' => 3,
-             'C' => 4,  'c' => 4,
-             'Q' => 5,  'q' => 5,
-             'E' => 6,  'e' => 6,
-             'G' => 7,  'g' => 7,
-             'H' => 8,  'h' => 8,
-             'I' => 9,  'i' => 9,
-             'L' => 10, 'l' => 10,
-             'K' => 11, 'k' => 11,
-             'M' => 12, 'm' => 12,
-             'F' => 13, 'f' => 13,
-             'P' => 14, 'p' => 14,
-             'S' => 15, 's' => 15,
-             'T' => 16, 't' => 16,
-             'W' => 17, 'w' => 17,
-             'Y' => 18, 'y' => 18,
-             'V' => 19, 'v' => 19,
-             'B' => 20, 'b' => 20,
-             'Z' => 21, 'z' => 21,
-             'X' => 22, 'x' => 22,
-             '*' => 23 }
-
-  INT2AA = { 0 => 'A', 1 => 'R', 2 => 'N', 3 => 'D',
-             4 => 'C', 5 => 'Q', 6 => 'E', 7 => 'G',
-             8 => 'H', 9 => 'I', 10 => 'L', 11 => 'K',
-             12 => 'M', 13 => 'F', 14 => 'P', 15 => 'S',
-             16 => 'T', 17 => 'W', 18 => 'Y', 19 => 'V',
-             20 => 'B', 21 => 'Z', 22 => 'X', 23 => '*' }
-
-  DNAElements = %w[A C G T N]
-
-  DNA2INT = { 'A' => 0, 'a' => 0,
-              'C' => 1, 'c' => 1,
-              'G' => 2, 'g' => 2,
-              'T' => 3, 't' => 3,
-              'N' => 4, 'n' => 4 }
-
-  INT2DNA = { 0 => 'A', 1 => 'C', 2 => 'G', 3 => 'T', 4 => 'N' }
-
-  # reverse complement
-  DNARC = { 'A' => 'T',
-            'C' => 'G',
-            'G' => 'C',
-            'T' => 'A',
-            'N' => 'N',
-            'a' => 'T',
-            'c' => 'G',
-            'g' => 'C',
-            't' => 'A',
-            'n' => 'N' }
+  require_relative 'ssw/libssw'
+  require_relative 'ssw/profile'
+  require_relative 'ssw/align'
 
   class << self
     # Create the query profile using the query sequence.
@@ -99,47 +41,59 @@ module LibSSW
     #   * if your estimated best alignment score is surely < 255 please set 0;
     #   * if your estimated best alignment score >= 255, please set 1;
     #   * if you don't know, please set 2
-    def ssw_init(read, mat, n = nil, score_size: 2)
+    def init(read, mat, n = nil, score_size: 2)
+      read = read.to_a
+      mat = mat.to_a.flatten
+      raise ArgumentError, 'Expect class of read to be Array' unless read.is_a?(Array)
+      raise ArgumentError, 'Expect class of mat to be Array' unless mat.is_a?(Array)
+
       read_str = read.pack('c*')
       read_len = read.size
-      mat = mat.to_a.flatten
       n = Math.sqrt(mat.size) if n.nil?
       raise "Not a square matrix. size: #{mat.size}, n: #{n}" if mat.size != n * n
 
       mat_str = mat.flatten.pack('c*')
-      ptr = FFI.ssw_init(
+      ptr = LibSSW.ssw_init(
         read_str,
         read_len,
         mat_str,
         n,
         score_size
       )
-      # Garbage collection workaround
+      # Garbage collection workaround:
+      # The C library stores pointers to read and mat without copying the data.
+      # We must keep the Ruby strings (read_str, mat_str) alive for the lifetime
+      # of the profile structure to prevent segmentation faults.
       #
-      # * The following code will cause a segmentation violation when manually
-      #   releasing memory. The reason is unknown.
-      # * func_map is only available in newer versions of fiddle.
-      # ptr.free = FFI.instance_variable_get(:@func_map)['init_destroy']
+      # We cannot use Fiddle's automatic memory management (ptr.free) here because:
+      # - Calling init_destroy from Ruby's GC causes segmentation violations
+      # - The user should explicitly call SSW.init_destroy when done, or let
+      #   Ruby's GC clean up the profile structure itself (though the contained
+      #   profile_byte/profile_word will leak unless init_destroy is called)
       ptr.instance_variable_set(:@read_str,   read_str)
-      ptr.instance_variable_set(:@read_len,   read_len)
       ptr.instance_variable_set(:@mat_str,    mat_str)
+      ptr.instance_variable_set(:@read_len,   read_len)
       ptr.instance_variable_set(:@n,          n)
       ptr.instance_variable_set(:@score_size, score_size)
 
-      LibSSW::Profile.new(ptr)
+      SSW::Profile.new(ptr)
     end
 
     # Release the memory allocated by function ssw_init.
-    # @param p [Fiddle::Pointer, LibSSW::Profile, LibSSW::FFI::Profile]
+    # @param profile [Fiddle::Pointer, SSW::Profile, SSW::LibSSW::Profile]
     #   pointer to the query profile structure
     # @note Ruby has garbage collection, so there is not much reason to call
     #   this method.
     def init_destroy(profile)
-      FFI.init_destroy(profile)
+      unless profile.is_a?(Fiddle::Pointer) || profile.is_a?(Profile) || profile.respond_to?(:to_ptr)
+        raise ArgumentError, 'Expect class of profile to be Profile or Pointer'
+      end
+
+      LibSSW.init_destroy(profile)
     end
 
     # Do Striped Smith-Waterman alignment.
-    # @param prof [Fiddle::Pointer, LibSSW::Profile, LibSSW::FFI::Profile]
+    # @param prof [Fiddle::Pointer, SSW::Profile, SSW::LibSSW::Profile]
     #   pointer to the query profile structure
     # @param ref [Array]
     #   target sequence;
@@ -148,25 +102,25 @@ module LibSSW
     # @param weight_gap0 [Integer] the absolute value of gap open penalty
     # @param weight_gapE [Integer] the absolute value of gap extension penalty
     # @param flag [Integer]
-    #   * bit 5: when setted as 1, function ssw_align will return the best
+    #   * bit 5: when set as 1, function ssw_align will return the best
     #     alignment beginning position;
-    #   * bit 6: when setted as 1, if (ref_end1 - ref_begin1 < filterd &&
-    #     read_end1 - read_begin1 < filterd), (whatever bit 5 is setted) the
+    #   * bit 6: when set as 1, if (ref_end1 - ref_begin1 < filterd &&
+    #     read_end1 - read_begin1 < filterd), (whatever bit 5 is set) the
     #     function will return the best alignment beginning position and cigar;
-    #   * bit 7: when setted as 1, if the best alignment score >= filters,
-    #     (whatever bit 5 is setted) the function   will return the best
+    #   * bit 7: when set as 1, if the best alignment score >= filters,
+    #     (whatever bit 5 is set) the function   will return the best
     #     alignment beginning position and cigar;
-    #   * bit 8: when setted as 1, (whatever bit 5, 6 or 7 is  setted) the
+    #   * bit 8: when set as 1, (whatever bit 5, 6 or 7 is  set) the
     #     function will always return the best alignment beginning position and
     #     cigar. When flag == 0, only the optimal and sub-optimal scores and the
     #     optimal alignment ending position will be returned.
     # @param filters [Integer]
-    #   scorefilter: when bit 7 of flag is setted as 1 and bit 8 is setted as 0,
-    #   filters will be used (Please check the decription of the flag parameter
+    #   scorefilter: when bit 7 of flag is set as 1 and bit 8 is set as 0,
+    #   filters will be used (Please check the description of the flag parameter
     #   for detailed usage.)
     # @param filterd [Integer]
-    #   distance filter: when bit 6 of flag is setted as 1 and bit 8 is setted
-    #   as 0, filterd will be used (Please check the decription of the flag
+    #   distance filter: when bit 6 of flag is set as 1 and bit 8 is set
+    #   as 0, filterd will be used (Please check the description of the flag
     #   parameter for detailed usage.)
     # @param mask_len [Integer]
     #   The distance between the optimal and suboptimal alignment ending
@@ -181,25 +135,40 @@ module LibSSW
     #   SSW C library masks the reference loci nearby (mask length = maskLen)
     #   the best alignment ending position and locates the second largest score
     #   from the unmasked elements.
-    def ssw_align(prof, ref, weight_gap0, weight_gapE, flag, filters, filterd, mask_len)
+    # @return [Align]
+    def align(prof, ref, weight_gap0, weight_gapE, flag, filters, filterd, mask_len = nil)
+      unless prof.is_a?(Fiddle::Pointer) || prof.is_a?(Profile) || prof.respond_to?(:to_ptr)
+        raise ArgumentError, 'Expect class of filename to be Profile or Pointer'
+      end
+      raise ArgumentError, 'Expect class of ref to be Array' unless ref.is_a?(Array)
+
       ref_str = ref.pack('c*')
       ref_len = ref.size
-      ptr = FFI.ssw_align(
+      mask_len ||= [ref_len / 2, 15].max
+      ptr = LibSSW.ssw_align(
         prof, ref_str, ref_len, weight_gap0, weight_gapE, flag, filters, filterd, mask_len
       )
-      # Not sure yet if we should set the instance variable to the pointer as a
-      # garbage collection workaround.
-      # For example: instance_variable_set(:@ref_str, ref_str)
-      #
-      # ptr.free = FFI.instance_variable_get(:@func_map)['align_destroy']
-      LibSSW::Align.new(ptr)
+      # Garbage collection workaround:
+      # Keep ref_str alive while the C code might still need it.
+      # However, since Align.new immediately reads all values and calls align_destroy,
+      # the C memory is freed immediately, so ref_str only needs to live until then.
+      # We store it on ptr just to be safe during the Align.new call.
+      ptr.instance_variable_set(:@ref_str, ref_str)
+      SSW::Align.new(ptr)
     end
 
     # Release the memory allocated by function ssw_align.
-    # @param a [Fiddle::Pointer, LibSSW::Align, LibSSW::FFI::Align]
+    # @param align [Fiddle::Pointer, SSW::Align, SSW::LibSSW::Align]
     #   pointer to the alignment result structure
     def align_destroy(align)
-      FFI.align_destroy(align)
+      if align.is_a?(Align)
+        warn "You don't need to call this method for Ruby's Align class."
+        nil
+      elsif align.is_a?(Fiddle::Pointer) || align.respond_to?(:to_ptr)
+        LibSSW.align_destroy(align)
+      else
+        raise ArgumentError, 'Expect class of align to be Pointer'
+      end
     end
 
     # 1. Calculate the number of mismatches.
@@ -226,22 +195,11 @@ module LibSSW
     # @return [Integer] The number of mismatches. The cigar and cigarLen are modified.
     def mark_mismatch(ref_begin1, read_begin1, read_end1, ref, read, read_len, cigar, cigar_len)
       warn 'implementation: fiexme: **cigar' # FIXME
-      FFI.mark_mismatch(
+      LibSSW.mark_mismatch(
         ref_begin1, read_begin1, read_end1, ref.pack('c*'), read.pack('c*'), read_len, cigar, cigar_len.pack('l*')
       )
     end
 
-    def array_to_cigar_string(arr)
-      cigar_string = String.new
-      arr.each do |x|
-        n = x >> 4
-        m = x & 15
-        c = m > 8 ? 'M' : 'MIDNSHP=X'[m]
-        cigar_string << n.to_s << c
-      end
-      cigar_string
-    end
-
     # Create scoring matrix of Smith-Waterman algrithum.
     # @param [Array] elements
     # @param [Integer] match_score
@@ -258,44 +216,41 @@ module LibSSW
       score
     end
 
-    # @param [String] seq
-    def dna_to_int_array(seq)
-      raise ArgumentError, 'seq must be a string' unless seq.is_a? String
-
-      seq.each_char.map do |base|
-        DNA2INT[base] || DNA2INT['N']
-      end
-    end
-
-    def dna_complement(seq)
-      seq.each_char.map do |base|
-        DNARC[base]
-      end.join.reverse
-    end
-
-    # @param [Array] int array
-    def int_array_to_dna(arr)
-      raise ArgumentError, 'arr must be an Array' unless arr.is_a? Array
-
-      arr.map do |i|
-        INT2DNA[i] || 'N'
-      end.join
-    end
-
-    def aaseq_to_int_array(seq)
-      raise ArgumentError, 'seq must be a string' unless seq.is_a? String
-
-      seq.each_char.map do |base|
-        AA2INT[base] || AA2INT['*']
+    # TODO: fix variable names
+    # @param q_seq [String] query sequence
+    # @param r_seq [String] reference sequence
+    # @param align [Align] alignment result
+    # @return [Array]
+    def build_path(q_seq, r_seq, align)
+      sQ = ''
+      sA = ''
+      sR = ''
+      q_off = align.read_begin1
+      r_off = align.ref_begin1
+      align.cigar.each do |x|
+        n = x >> 4
+        m = x & 15
+        c = m > 8 ? 'M' : 'MIDNSHP=X'[m]
+        case c
+        when 'M'
+          sQ += q_seq[q_off...(q_off + n)]
+          sA += Array.new(n) { |j| q_seq[q_off + j] == r_seq[r_off + j] ? '|' : '*' }.join
+          sR += r_seq[r_off...(r_off + n)]
+          q_off += n
+          r_off += n
+        when 'I'
+          sQ += q_seq[q_off...(q_off + n)]
+          sA += ' ' * n
+          sR += ' ' * n
+          q_off += n
+        when 'D'
+          sQ += ' ' * n
+          sA += ' ' * n
+          sR += r_seq[r_off...(r_off + n)]
+          r_off += n
+        end
       end
-    end
-
-    def int_array_to_aaseq(arr)
-      raise ArgumentError, 'arr must be an Array' unless arr.is_a? Array
-
-      arr.map do |i|
-        INT2AA[i] || '*'
-      end.join
+      [align.cigar_string, sQ, sA, sR]
     end
   end
 end

data/lib/{libssw → ssw}/BLOSUM50.rb

@@ -1,4 +1,4 @@
-module LibSSW
+module SSW
   BLOSUM50 = [
   #  A   R   N   D   C   Q   E   G   H   I   L   K   M   F   P   S   T   W   Y   V   B   Z   X   *
      5, -2, -1, -2, -1, -1, -1,  0, -2, -1, -2, -1, -1, -3, -1,  1,  0, -3, -2,  0, -2, -1, -1, -5, # A

data/lib/{libssw → ssw}/BLOSUM62.rb

@@ -1,4 +1,4 @@
-module LibSSW
+module SSW
   BLOSUM62 = [
   #  A   R   N   D   C   Q   E   G   H   I   L   K   M   F   P   S   T   W   Y   V   B   Z   X   *
      4, -1, -2, -2,  0, -1, -1,  0, -2, -1, -1, -1, -1, -2, -1,  1,  0, -3, -2,  0, -2, -1,  0, -4, # A

data/lib/ssw/aaseq.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module SSW
+  module AASeq
+    AAELEMENTS = ['A', 'R', 'N', 'D', 'C', 'Q', 'E', 'G',
+                  'H', 'I', 'L', 'K', 'M', 'F', 'P', 'S',
+                  'T', 'W', 'Y', 'V', 'B', 'Z', 'X', '*'].freeze
+
+    AA2INT = { 'A' => 0,  'a' => 0,
+               'R' => 1,  'r' => 1,
+               'N' => 2,  'n' => 2,
+               'D' => 3,  'd' => 3,
+               'C' => 4,  'c' => 4,
+               'Q' => 5,  'q' => 5,
+               'E' => 6,  'e' => 6,
+               'G' => 7,  'g' => 7,
+               'H' => 8,  'h' => 8,
+               'I' => 9,  'i' => 9,
+               'L' => 10, 'l' => 10,
+               'K' => 11, 'k' => 11,
+               'M' => 12, 'm' => 12,
+               'F' => 13, 'f' => 13,
+               'P' => 14, 'p' => 14,
+               'S' => 15, 's' => 15,
+               'T' => 16, 't' => 16,
+               'W' => 17, 'w' => 17,
+               'Y' => 18, 'y' => 18,
+               'V' => 19, 'v' => 19,
+               'B' => 20, 'b' => 20,
+               'Z' => 21, 'z' => 21,
+               'X' => 22, 'x' => 22,
+               '*' => 23 }.freeze
+
+    INT2AA = { 0 => 'A', 1 => 'R', 2 => 'N', 3 => 'D',
+               4 => 'C', 5 => 'Q', 6 => 'E', 7 => 'G',
+               8 => 'H', 9 => 'I', 10 => 'L', 11 => 'K',
+               12 => 'M', 13 => 'F', 14 => 'P', 15 => 'S',
+               16 => 'T', 17 => 'W', 18 => 'Y', 19 => 'V',
+               20 => 'B', 21 => 'Z', 22 => 'X', 23 => '*' }.freeze
+
+    module_function
+
+    # Transform amino acid sequence into numerical sequence.
+    # @param seq [String] amin acid sequence
+    # @return [Array] int array
+    # @example
+    #   SSW::AASeq.to_int_array("ARND") #=> [0, 1, 2, 3]
+
+    def to_int_array(seq)
+      raise ArgumentError, 'seq must be a string' unless seq.is_a? String
+
+      seq.each_char.map do |base|
+        AA2INT[base] || AA2INT['*']
+      end
+    end
+
+    # Transform numerical sequence into amino acid sequence.
+    # @param arr [Array] int array
+    # @return [String] amino acid sequence
+    # @example
+    #   SSW::AASeq.from_int_array([0, 1, 2, 3]) #=> "ARND"
+
+    def from_int_array(arr)
+      raise ArgumentError, 'arr must be an Array' unless arr.is_a? Array
+
+      arr.map do |i|
+        INT2AA[i] || '*'
+      end.join
+    end
+  end
+end

data/lib/{libssw → ssw}/align.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module LibSSW
+module SSW
   # structure of the alignment result
   # @!attribute score1
   #   @return [Integer] the best alignment score
@@ -28,7 +28,9 @@ module LibSSW
   # @!attribute cigar_len
   #   @return [Integer]
   #     length of the cigar string; cigarLen = 0 when the best alignment path is not available
-  class Align < FFI::Align
+  # @!attribute cigar_string
+  #   @return [String] cigar string
+  class Align
     def self.keys
       %i[score1 score2 ref_begin1 ref_end1
          read_begin1 read_end1 ref_end2 cigar cigar_len cigar_string]
@@ -39,7 +41,7 @@ module LibSSW
 
     def initialize(ptr)
       @ptr          = ptr
-      @cstruct      = align = FFI::Align.new(ptr)
+      @cstruct      = align = LibSSW::Align.new(ptr)
       @score1       = align.score1
       @score2       = align.score2
       @ref_begin1   = align.ref_begin1
@@ -50,12 +52,25 @@ module LibSSW
       @cigar_len    = align.cigarLen
       @cigar        = cigar_len.positive? ? align.cigar[0, 4 * cigar_len].unpack('L*') : []
       # Attributes for ruby binding only
-      @cigar_string = LibSSW.array_to_cigar_string(@cigar)
-      LibSSW.align_destroy(ptr)
+      @cigar_string = array_to_cigar_string(@cigar)
+      SSW.align_destroy(ptr)
     end
 
     def to_h
       self.class.keys.map { |k| [k, __send__(k)] }.to_h
     end
+
+    private
+
+    def array_to_cigar_string(arr)
+      cigar_string = String.new
+      arr.each do |x|
+        n = x >> 4
+        m = x & 15
+        c = m > 8 ? 'M' : 'MIDNSHP=X'[m]
+        cigar_string << n.to_s << c
+      end
+      cigar_string
+    end
   end
 end

data/lib/ssw/dna.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module SSW
+  module DNA
+    Elements = %w[A C G T N].freeze
+
+    DNA2INT = { 'A' => 0, 'a' => 0,
+                'C' => 1, 'c' => 1,
+                'G' => 2, 'g' => 2,
+                'T' => 3, 't' => 3,
+                'N' => 4, 'n' => 4 }.freeze
+
+    INT2DNA = { 0 => 'A', 1 => 'C', 2 => 'G', 3 => 'T', 4 => 'N' }.freeze
+
+    # reverse complement
+    DNARC = { 'A' => 'T',
+              'C' => 'G',
+              'G' => 'C',
+              'T' => 'A',
+              'N' => 'N',
+              'a' => 'T',
+              'c' => 'G',
+              'g' => 'C',
+              't' => 'A',
+              'n' => 'N' }.freeze
+
+    module_function
+
+    # Transform DNA sequence into numerical sequence.
+    # @param seq [String] dna sequence
+    # @return [Array] int array
+    # @example
+    #   SSW::DNA.to_int_array("TCGA") #=> [3, 1, 2, 0]
+
+    def to_int_array(seq)
+      raise ArgumentError, 'seq must be a string' unless seq.is_a? String
+
+      seq.each_char.map do |base|
+        DNA2INT[base] || DNA2INT['N']
+      end
+    end
+
+    # Transform numerical sequence into DNA sequence.
+    # @param arr [Array] int array
+    # @return [String] dna sequence
+    # @example
+    #   SSW::DNA.from_int_array([3, 1, 2, 0]) #=> "TCGA"
+
+    def from_int_array(arr)
+      raise ArgumentError, 'arr must be an Array' unless arr.is_a? Array
+
+      arr.map do |i|
+        INT2DNA[i] || 'N'
+      end.join
+    end
+
+    # reverse complement
+    # @param seq [String] sequence
+    # @return [String] reverse complement
+    # @example
+    #   SSW::DNA.revcomp("TCGAT") #=> "ATCGA"
+
+    def revcomp(seq)
+      seq.each_char.map do |base|
+        DNARC[base]
+      end.join.reverse
+    end
+  end
+end

data/lib/{libssw/ffi.rb → ssw/libssw.rb}

@@ -2,12 +2,12 @@
 
 require 'fiddle/import'
 
-module LibSSW
-  module FFI
+module SSW
+  module LibSSW
     extend Fiddle::Importer
 
     begin
-      dlload LibSSW.ffi_lib
+      dlload SSW.ffi_lib
     rescue LoadError => e
       raise LoadError, "Could not find libssw shared library. \n#{e}"
     end

data/lib/{libssw → ssw}/profile.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-module LibSSW
+module SSW
   # structure of the query profile/usr/lib/x86_64-linux-gnu/
   # @!attribute read
   # @!attribute mat
   # @!attribute read_len
   # @!attribute n
   # @!attribute bias
-  class Profile < FFI::Profile
+  class Profile
     def self.keys
       %i[read mat read_len n bias]
     end
@@ -17,7 +17,7 @@ module LibSSW
 
     def initialize(ptr)
       @ptr      = ptr
-      @cstruct  = profile = LibSSW::FFI::Profile.new(ptr)
+      @cstruct  = profile = SSW::LibSSW::Profile.new(ptr)
       @read_len = profile.readLen
       @read     = read_len.positive? ? profile.read[0, read_len].unpack('c*') : []
       @n        = profile.n
@@ -26,13 +26,11 @@ module LibSSW
     end
 
     def to_ptr
-      # Garbage collection warkaround
-      # Preventing Garbage Collection --force
-      cstruct.read    = ptr.instance_variable_get(:@read_str)
-      cstruct.mat     = ptr.instance_variable_get(:@mat_str)
-      cstruct.readLen = ptr.instance_variable_get(:@read_len)
-      cstruct.n       = ptr.instance_variable_get(:@n)
-      ptr
+      # The pointer already contains the correct C structure.
+      # The instance variables on @ptr (@read_str, @mat_str, etc.) are kept
+      # alive to prevent garbage collection of the memory that C is referencing.
+      # We don't need to modify the C structure here.
+      @ptr
     end
 
     def to_h

data/lib/{libssw → ssw}/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-module LibSSW
-  VERSION = '0.0.2'
+module SSW
+  VERSION = '0.0.5'
 end

metadata

@@ -1,107 +1,22 @@
 --- !ruby/object:Gem::Specification
 name: libssw
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.5
 platform: ruby
 authors:
 - kojix2
-autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2021-01-22 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fiddle
   requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.0.7
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.0.7
-- !ruby/object:Gem::Dependency
-  name: bio
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -111,26 +26,25 @@ dependencies:
 description: Ruby bindings for libssw
 email:
 - 2xijok@gmail.com
-executables:
-- rbssw
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE.txt
 - README.md
-- exe/rbssw
 - lib/libssw.rb
-- lib/libssw/BLOSUM50.rb
-- lib/libssw/BLOSUM62.rb
-- lib/libssw/align.rb
-- lib/libssw/ffi.rb
-- lib/libssw/profile.rb
-- lib/libssw/version.rb
+- lib/ssw/BLOSUM50.rb
+- lib/ssw/BLOSUM62.rb
+- lib/ssw/aaseq.rb
+- lib/ssw/align.rb
+- lib/ssw/dna.rb
+- lib/ssw/libssw.rb
+- lib/ssw/profile.rb
+- lib/ssw/version.rb
 homepage: https://github.com/kojix2/ruby-libssw
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -145,8 +59,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Ruby bindings for libssw
 test_files: []

data/exe/rbssw

@@ -1,193 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-warn 'This script is under development.'
-warn "It doesn't work properly yet!"
-
-require 'bio'
-require 'libssw'
-SSW = LibSSW
-require 'optparse'
-
-opts = {
-  lib_path: nil,
-  nmatch: 2,
-  nmismatch: 2,
-  nopen: 3,
-  next: 1,
-  bprotein: false,
-  smatrix: nil,
-  bpath: false,
-  nthr: nil,
-  bbest: false,
-  bsam: nil, # typo?
-  bheader: nil
-}
-
-parser = OptionParser.new do |opt|
-  opt.version = LibSSW::VERSION
-  opt.summary_width = 20
-  opt.banner = 'Usage: rbssw [options] <target file> <query file>'
-  opt.on('-l', '--sLibPath PATH', String,
-         'path of libssw.so') do |v|
-           opts[:sLibPath] = v
-         end
-  opt.on('-m', '--nMatch VAL', Integer,
-         'a positive integer as the score for a match',
-         "in genome sequence alignment. [#{opts[:nmatch]}]") do |v|
-           opts[:nmatch] = v
-         end
-  opt.on('-x', '--nMismatch VAL', Integer,
-         'a positive integer as the score for a mismatch',
-         "in genome sequence alignment. [#{opts[:nmismatch]}]") do |v|
-           opts[:nmismatch] = v
-         end
-  opt.on('-o', '--nOpen VAL', Integer,
-         'a positive integer as the penalty for the gap opening',
-         "in genome sequence alignment. [#{opts[:nopen]}]") do |v|
-           opts[:nopen] = v
-         end
-  opt.on('-e', '--nExt VAL', Integer,
-         'a positive integer as the penalty for the gap extension',
-         "in genome sequence alignment. [#{opts[:next]}]") do |v|
-           opts[:next] = v
-         end
-  opt.on('-p', '--bProtien', TrueClass,
-         'Do protein sequence alignment.',
-         "Without this option, do genome sequence alignment. [#{opts[:bprotein]}]") do |v|
-           opts[:bprotein] = v
-         end
-  opt.on('-a', '--sMatrix VAL', String,
-         "a file for either Blosum or Pam weight matrix. [#{opts[:smatrix]}]") do |v|
-           opts[:smatrix] = v
-         end
-  opt.on('-c', '--bPath', TrueClass,
-         "Return the alignment path. [#{opts[:bpath]}]") do |v|
-           opts[:bpath] = v
-         end
-  opt.on('-f', '--nThr VAL', Integer,
-         'a positive integer.',
-         'Only output the alignments with the Smith-Waterman score >= N.') do |v|
-           opts[:nthr] = v
-         end
-  opt.on('-r', '--bBest', TrueClass,
-         'The best alignment will be picked, between the original read',
-         "alignment and the reverse complement read alignment. [#{opts[:bbest]}]") do |v|
-           opts[:bbest] = v
-         end
-  opt.on('-s', '--bSam', TrueClass,
-         'Output in SAM format. [no header]') do |v| # TYPO?
-           opts[:bsam] = v
-         end
-  opt.on('-header', '--bHeader', TrueClass,
-         'If -s is used, include header in SAM output.') do |v|
-           opts[:bheader] = v
-         end
-end
-
-parser.order!(ARGV)
-
-opts[:target] = ARGV[0]
-opts[:query]  = ARGV[1]
-
-lEle = []
-dRc = {}
-dEle2Int = {}
-dInt2Ele = {}
-lScore = nil
-
-if opts[:bprotein]
-  # load AA score matrix
-  if !opts[:smatrix]
-    lEle = SSW::AAELEMENTS
-    dEle2Int = SSW::AA2INT
-    dInt2Ele = SSW::INT2AA
-    nEleNum = lEle.size
-    lScore = SSW::Blosum50
-  else
-    lEle, dEle2Int, dInt2Ele, lScore = SSW.read_matrix(opts[:smatrix])
-  end
-elsif !opts[:smatrix]
-  # init DNA score matrix
-  lEle = SSW::DNAELEMENTS
-  dRc = SSW::DNARC
-  dEle2Int = SSW::DNA2INT
-  dInt2Ele = SSW::INT2DNA
-  nEleNum = lEle.size # 5
-  lScore = LibSSW.create_scoring_matrix(lEle, opts[:nmatch], -opts[:nmismatch])
-end
-
-warn 'Reverse complement alignment is not available for protein sequences.' if opts[:bbest] && opts[:bprotein]
-
-# set flag
-nFlag = opts[:bpath] ? 2 : 0
-
-# print sam head
-if opts[:bsam] && opts[:bheader] && opts[:bpath]
-  puts '@HD\tVN:1.4\tSO:queryname'
-  Bio::Flatfile.open(opts[:target]) do |f|
-    f.each do |entry|
-      id  = entry.entry_id
-      len = entry.nalen
-      puts "@SQ\tSN:#{id}\tLN:#{len}"
-    end
-  end
-elsif opts[:bsam] && !args[:bpath]
-  warn 'SAM format output is only available together with option -c.\n'
-  opts[:bsam] = false
-end
-
-def _to_int(seq, lEle, dEle2Int)
-  seq.each_char.map do |ele|
-    if dEle2Int.has_key?(ele)
-      dEle2Int[ele]
-    else
-      dEle2Int[lEle[-1]]
-    end
-  end
-end
-
-# iterate query sequenc
-Bio::FlatFile.open(opts[:query]) do |query_file|
-  query_file.each do |qentry|
-    sQId   = qentry.entry_id
-    sQSeq  = qentry.sequence_string
-    sQQual = qentry.quality_string
-    # build query profile
-    qNum = _to_int(sQSeq, lEle, dEle2Int)
-    qProfile = SSW.ssw_init(qNum, sQSeq.size, lScore, lEle.size, 2)
-    # build rc query profile
-    if opts[:bbest] && !opts[:bprotein]
-      sQRcSeq = sQSeq.reverse.each_char.map { |x| dRc[x] }.join
-      qRcNum = _to_int(sQRcSeq, lEle, dEle2Int)
-      qRcProfile = SSW.ssw_init(qRcNum, sQSeq.size, mat, lEle.size, 2)
-    end
-    # set mask le
-    if sQSeq.size > 30
-      nMaskLen = sQSeq.size / 2
-    else
-      nMasklen = 15
-    end
-
-    # iter target sequence
-    Bio::FlatFile.open(opts[:target]) do |target_file|
-      target_file.each do |tentry|
-        sRId  = tentry.entry_id
-        sRSeq = tentry.seq.to_s
-        rNum  = _to_int(sRSeq, lEle, dEle2Int)
-        res = SSW.ssw_align(
-          qProfile, rNum, sRSeq.size, opts[:nopen], opts[:next], nFlag, 0, 0, nMaskLen
-        )
-        p res.to_h
-        resRc = nil
-        if opts[:bbest] && !opts[:bprotein]
-          resRc = SSW.align_one(
-            qRcProfile, rNum, sRSeq.size, opts[:nopen], opts[:next], nFlag, 0, 0, nMaskLen
-          )
-        end
-        # build cigar and trace back path
-        strand = 0
-      end
-    end
-  end
-end