bio 2.0.2 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c68318f6e170c45020baac59d2be85490d901837ffe5ec136b86ac80901618f
-  data.tar.gz: 5e2813540c9789252d3be786076fe56e6b64dc07655c0bee0873847b643c3dfa
+  metadata.gz: 990d6888c3a4e53089aaf8332c4bc87bb9cc40efe25e1aa13b7337be69145227
+  data.tar.gz: 361fad495b8f8ee3528a6729b8a52a3522a6d594353679a6a84993e97e1e8f6a
 SHA512:
-  metadata.gz: 03b065e96fcd4afcf1e6c95207ca2999d8855a16e25c11a3d2aa1478ff9ae3e0686887e501f53ff7b3fa4cbf10cd8200a0ac667282b191d7ade47e6122dfd678
-  data.tar.gz: 0c152f67d43b8ad359f2beef4dc84f134ab26f08490fb151a76fa5149380174cb65058831095c21618836eb01f1b785b88ed5cbf3cfb90687a6649f002aa51be
+  metadata.gz: 52c72d6055da72526d208e85b42ad75b150b4538b62c2552323e5f344721b9fe0ed3b18adf5e9d570f9d34fba019379fc6528a329a1340962f5a9c6c279e458c
+  data.tar.gz: f8894738bbb973722b77f65559f56b2ec661619e9f2dfe060456d63523fb921d4697d619171a8998686d234ac6bb5f3a300cbd140c8a78f8083b36029b536825

data/ChangeLog

@@ -1,3 +1,139 @@
+commit c16e230d15cf30478a3739563b4e4745dc57ef82
+Author: Naohisa Goto <ng@bioruby.org>
+Date:   Fri Nov 5 23:44:45 2021 +0900
+
+    regenerate bioruby.gemspec with rake regemspec
+
+ bioruby.gemspec | 3 ++-
+ 1 file changed, 2 insertions(+), 1 deletion(-)
+
+commit 1a8c44dc5b8d24342550273a594e5f75e41f41df
+Author: Naohisa Goto <ng@bioruby.org>
+Date:   Fri Nov 5 23:41:29 2021 +0900
+
+    prepare for BioRuby 2.0.3 release
+
+ lib/bio/version.rb | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 863242cdb9a748ba9efb3be3b39f92c17ed3ea84
+Author: Naohisa Goto <ng@bioruby.org>
+Date:   Fri Nov 5 23:36:27 2021 +0900
+
+    update release notes for upcoming BioRuby 2.0.3
+
+ RELEASE_NOTES.rdoc | 26 ++++++++++++++++++++++++++
+ 1 file changed, 26 insertions(+)
+
+commit b97794d632c73dc45639cec000fb11238740eb30
+Author: Naohisa Goto <ng@bioruby.org>
+Date:   Fri Nov 5 23:26:20 2021 +0900
+
+    Ruby 3.0 compatibility fix: Bio::Sequence::*#partition, #rpartiton
+    
+     * Behaviors of Bio::Sequence::*#partition and #rpartition in Ruby 3.0
+       are changed to mimic those in Ruby 2.x.
+
+ lib/bio/sequence/common.rb           | 17 +++++++
+ test/unit/bio/sequence/test_ruby3.rb | 94 ++++++++++++++++++++++++++++++++++++
+ 2 files changed, 111 insertions(+)
+
+commit 7ff79cd449ee03e0063120fb9abec50d9b08e979
+Author: Naohisa Goto <ng@bioruby.org>
+Date:   Fri Nov 5 22:24:16 2021 +0900
+
+    remove resolved Ruby 3.0 issue
+
+ KNOWN_ISSUES.rdoc | 8 --------
+ 1 file changed, 8 deletions(-)
+
+commit 24bb3c3cf417837ad63a27913db7237aef1414c6
+Author: Naohisa Goto <ng@bioruby.org>
+Date:   Fri Nov 5 21:24:26 2021 +0900
+
+    Bio::Sequence::NA,AA,Generic: workaround for Ruby 3.0.0 incompatible change
+    
+     * Since Ruby 3.0.0, over 30 methods in subclass of String class are
+       changed to return/yield String instance instead of the subclass
+       instance. (https://github.com/ruby/ruby/blob/v3_0_0/NEWS.md )
+    
+     * In this commit, workaround is made for the following methods:
+       * *
+       * capitalize
+       * center
+       * chomp
+       * chop
+       * delete
+       * delete_prefix
+       * delete_suffix
+       * downcase
+       * each_char
+       * each_grapheme_cluster
+       * each_line
+       * gsub
+       * gsub!
+       * ljust
+       * lstrip
+       * revserse
+       * rjust
+       * rstrip
+       * slice!
+       * slice / []
+       * split
+       * squeeze
+       * strip
+       * sub
+       * sub!
+       * succ / next
+       * swapcase
+       * tr
+       * tr_s
+       * upcase
+     * Note: sub! and gsub! are not described in the NEWS.md
+       but are also affected by this Ruby 3.0.0 incompatible changes.
+    
+     * The following methods are not patched i.e. they return/yield
+       String instances.
+       * dump
+       * partition
+       * rpartition
+       * scrub
+     * Note: In Ruby 2.7 or earlier, Bio::Sequence::NA#partition
+       and #rpartition methods return an array that may contain
+       mixture of Bio::Sequence::NA instances and String instances.
+    
+     * test/unit/bio/sequence/test_ruby3.rb: unit tests for the
+       above methods.
+    
+     * Close https://github.com/bioruby/bioruby/issues/137
+
+ lib/bio/sequence/common.rb           |  95 +++++++++
+ test/unit/bio/sequence/test_ruby3.rb | 368 +++++++++++++++++++++++++++++++++++
+ 2 files changed, 463 insertions(+)
+ create mode 100644 test/unit/bio/sequence/test_ruby3.rb
+
+commit 0efc0a54685d43645daa9c53d7140bfb81577777
+Author: kojix2 <2xijok@gmail.com>
+Date:   Tue Aug 31 19:39:25 2021 +0900
+
+    Fix typos: Retrun -> Return
+
+ lib/bio/appl/iprscan/report.rb | 6 +++---
+ lib/bio/appl/sosui/report.rb   | 2 +-
+ lib/bio/db/embl/uniprotkb.rb   | 2 +-
+ lib/bio/db/go.rb               | 4 ++--
+ lib/bio/tree.rb                | 2 +-
+ 5 files changed, 8 insertions(+), 8 deletions(-)
+
+commit a291b5a72da12a5cc8b006d1dd63d002fda5dff3
+Author: Naohisa Goto <ng@bioruby.org>
+Date:   Thu Dec 31 23:52:54 2020 +0900
+
+    BioRuby 2.0.2 is released
+
+ ChangeLog | 98 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 98 insertions(+)
+
 commit fd420b713ca364e677ef3551919ec907791df86d
 Author: Naohisa Goto <ng@bioruby.org>
 Date:   Thu Dec 31 23:51:08 2020 +0900

data/KNOWN_ISSUES.rdoc

@@ -12,14 +12,6 @@ they are not BioRuby's issues and/or it is very difficult to fix them.
 
 == 1. Ruby version specific issues
 
-==== Ruby 3.0
-
-Since Ruby 3.0, internal inplementation of String methods are changed and
-methods in a subclass of String return String instead of the subclass
-instance. Bio::Sequence::NA, AA, and Generic inherit String and are severely
-affected by this change.
-See GitHub issue https://github.com/bioruby/bioruby/issues/137 .
-
 ==== String encodings
 
 Currently, BioRuby do not care string encodings. In some cases,

data/RELEASE_NOTES.rdoc

@@ -1,3 +1,29 @@
+= BioRuby 2.0.3 RELEASE NOTES
+
+Some bug fixes have been made in BioRuby 2.0.3 after the release of 2.0.2.
+
+== Bug fixes
+
+* Fix Ruby 3.0.0 Bio::Sequence::* issue.
+  (https://github.com/bioruby/bioruby/issues/137 )
+* Fix typo (https://github.com/bioruby/bioruby/pull/145 )
+
+== Incompatible changes
+
+=== Bio::Sequence::* incompatible changes since Ruby 3.0.0
+
+Since Ruby 3.0.0, the following methods in Bio::Sequence::NA,
+Bio::Sequence::AA, and Bio::Sequence::Generic return or yield
+String instance, instead of the Bio::Sequence::* instance.
+
+* dump
+* scrub
+
+For details about Ruby 3.0.0 incompatible changes, see
+{News for Ruby 3.0.0}[https://github.com/ruby/ruby/blob/v3_0_0/NEWS.md].
+
+
+
 = BioRuby 2.0.2 RELEASE NOTES
 
 Some bugs fixes have been made in BioRuby 2.0.2 after the release of 2.0.1.

data/bioruby.gemspec

@@ -3,7 +3,7 @@
 # 
 Gem::Specification.new do |s|
   s.name = 'bio'
-  s.version = "2.0.2"
+  s.version = "2.0.3"
 
   s.author = "BioRuby project"
   s.email = "staff@bioruby.org"
@@ -546,6 +546,7 @@ Gem::Specification.new do |s|
     "test/unit/bio/sequence/test_dblink.rb",
     "test/unit/bio/sequence/test_na.rb",
     "test/unit/bio/sequence/test_quality_score.rb",
+    "test/unit/bio/sequence/test_ruby3.rb",
     "test/unit/bio/sequence/test_sequence_masker.rb",
     "test/unit/bio/test_alignment.rb",
     "test/unit/bio/test_command.rb",

data/lib/bio/appl/iprscan/report.rb

@@ -83,7 +83,7 @@ module Bio
         yield Bio::Iprscan::Report.parse_raw_entry(entry) if entry != ''
       end
     
-      # Parser method for a raw formated entry. Retruns a Bio::Iprscan::Report 
+      # Parser method for a raw formated entry. Returns a Bio::Iprscan::Report 
       # object.
       def self.parse_raw_entry(str)
         report = self.new
@@ -113,7 +113,7 @@ module Bio
 
 
 
-      # Parser method for a xml formated entry. Retruns a Bio::Iprscan::Report 
+      # Parser method for a xml formated entry. Returns a Bio::Iprscan::Report 
       # object.
 #      def self.parse_xml(str)
 #      end
@@ -196,7 +196,7 @@ module Bio
         end
       end
 
-      # Parser method for a pseudo-txt formated entry. Retruns a Bio::Iprscan::Report 
+      # Parser method for a pseudo-txt formated entry. Returns a Bio::Iprscan::Report 
       # object.
       # 
       # == Usage

data/lib/bio/appl/sosui/report.rb

@@ -78,7 +78,7 @@ module Bio
         # Returns aRng of transmembrane helix
         attr_reader :range
         
-        # Retruns ``PRIMARY'' or ``SECONDARY'' of helix.
+        # Returns ``PRIMARY'' or ``SECONDARY'' of helix.
         attr_reader :grade
 
         # Returns the sequence. of transmembrane helix. 

data/lib/bio/db/embl/uniprotkb.rb

@@ -174,7 +174,7 @@ class UniProtKB < EMBLDB
   #
   # http://www.uniprot.org/docs/sp_news.htm
   def parse_DE_line_rel14(str)
-    # Retruns if it is not the new format since Rel.14
+    # Returns if it is not the new format since Rel.14
     return nil unless /^DE   (RecName|AltName|SubName)\: / =~ str
     ret = []
     cur = nil

data/lib/bio/db/go.rb

@@ -193,7 +193,7 @@ class GO
     # Delimiter
     RS = DELIMITER 
 
-    # Retruns an Array of parsed gene_association flatfile.
+    # Returns an Array of parsed gene_association flatfile.
     # Block is acceptable.  
     def self.parser(str)
       if block_given?
@@ -226,7 +226,7 @@ class GO
     # Returns Db_Reference variable.
     attr_reader :db_reference      # -> []
 
-    # Retruns Evidence code variable.
+    # Returns Evidence code variable.
     attr_reader :evidence
 
     # Returns the entry is associated with this value.

data/lib/bio/sequence/common.rb

@@ -303,6 +303,118 @@ module Common
   end
   alias splicing splice
 
+#--
+# Workaround for Ruby 3.0.0 incompatible changes
+if ::RUBY_VERSION > "3"
+
+  # Acts almost the same as String#split.
+  def split(*arg)
+    if block_given?
+      super
+    else
+      ret = super(*arg)
+      ret.collect! { |x| self.class.new('').replace(x) }
+      ret
+    end
+  end
+
+  %w( * ljust rjust center ).each do |w|
+    module_eval %Q{
+      def #{w}(*arg)
+        self.class.new('').replace(super)
+      end
+    }
+  end
+
+  %w( chomp chop
+      delete delete_prefix delete_suffix
+      lstrip rstrip strip
+      reverse
+      squeeze
+      succ next
+      tr tr_s
+      capitalize upcase downcase swapcase
+  ).each do |w|
+    module_eval %Q{
+      def #{w}(*arg)
+        s = self.dup
+        s.#{w}!(*arg)
+        s
+      end
+    }
+  end
+
+  %w( sub gsub ).each do |w|
+    module_eval %Q{
+      def #{w}(*arg, &block)
+        s = self.dup
+        s.#{w}!(*arg, &block)
+        s
+      end
+    }
+  end
+
+  #Reference: https://nacl-ltd.github.io/2018/11/08/gsub-wrapper.html
+  #(Title: Is it possible to implement gsub wrapper?)
+  %w( sub! gsub! ).each do |w|
+    module_eval %Q{
+      def #{w}(*arg, &block)
+        if block_given? then
+          super(*arg) do |m|
+            b = Thread.current[:_backref]
+            Thread.current[:_backref] = ::Regexp.last_match
+            block.binding.eval("$~ = Thread.current[:_backref]")
+            Thread.current[:_backref] = b
+            block.call(self.class.new('').replace(m))
+          end
+        else
+          super
+        end
+      end
+    }
+  end
+
+  %w( each_char each_grapheme_cluster each_line ).each do |w|
+    module_eval %Q{
+      def #{w}
+        if block_given?
+          super { |c| yield(self.class.new('').replace(c)) }
+        else
+          enum_for(:#{w})
+        end
+     end
+    }
+  end
+
+  %w( slice [] slice! ).each do |w|
+    module_eval %Q{
+      def #{w}(*arg)
+        r = super
+        r ? self.class.new('').replace(r) : r
+      end
+    }
+  end
+
+  %w( partition rpartition ).each do |w|
+    module_eval %Q{
+      def #{w}(sep)
+        r = super
+        if r.kind_of?(Array)
+          r[1] == sep ?
+            [ self.class.new('').replace(r[0]),
+              r[1],
+              self.class.new('').replace(r[2]) ] :
+            r.collect { |x| self.class.new('').replace(x) }
+        else
+          r
+        end
+      end
+    }
+  end
+#++
+
+end # if ::RUBY_VERSION > "3"
+
 end # Common
 
 end # Sequence

data/lib/bio/tree.rb

@@ -605,7 +605,7 @@ module Bio
     end
 
     # Gets path from node1 to node2.
-    # Retruns an array of nodes, including node1 and node2.
+    # Returns an array of nodes, including node1 and node2.
     # If node1 and/or node2 do not exist, IndexError is raised.
     # If node1 and node2 are not connected, NoPathError is raised.
     # The result is unspecified for cyclic trees.

data/lib/bio/version.rb

@@ -10,7 +10,7 @@
 module Bio
 
   # BioRuby version (Array containing Integer)
-  BIORUBY_VERSION = [2, 0, 2].extend(Comparable).freeze
+  BIORUBY_VERSION = [2, 0, 3].extend(Comparable).freeze
 
   # Extra version specifier (String or nil).
   # Existance of the value indicates development version.

data/test/unit/bio/sequence/test_ruby3.rb

@@ -0,0 +1,462 @@
+#
+# test/unit/bio/sequence/test_ruby3.rb - Unit test for Bio::Sequencce::Common with Ruby version 3
+#
+# Copyright::   Copyright (C) 2021 BioRuby Project
+# Maintainter:: Naohisa Goto <ng@bioruby.org>
+# License::     The Ruby License
+#
+
+# loading helper routine for testing bioruby
+require 'pathname'
+load Pathname.new(File.join(File.dirname(__FILE__), ['..'] * 3,
+                            'bioruby_test_helper.rb')).cleanpath.to_s
+
+# libraries needed for the tests
+require 'test/unit'
+require 'bio/sequence'
+require 'bio/sequence/common'
+
+module Bio; module TestSequenceRuby3
+
+  class TSeq < String
+    include Bio::Sequence::Common
+  end
+
+  class TestSequenceCommon < Test::Unit::TestCase
+
+    def test_multiply
+      str = 'atgc'.freeze
+      obj = TSeq.new(str)
+      val = obj * 3
+      assert_instance_of(TSeq, val)
+      assert_equal(TSeq.new(str * 3), val)
+    end
+
+    def test_chomp
+      [ "atgc\n".freeze, "atgc".freeze ].each do |str|
+        obj = TSeq.new(str)
+        val = obj.chomp
+        assert_instance_of(TSeq, val)
+        assert_equal(TSeq.new(str.chomp), val)
+      end
+    end
+
+    def test_chop
+      [ "atgc\n".freeze, "atgc".freeze ].each do |str|
+        obj = TSeq.new(str)
+        val = obj.chop
+        assert_instance_of(TSeq, val)
+        assert_equal(TSeq.new(str.chop), val)
+      end
+    end
+
+    def test_delete
+      str = "atgggc".freeze
+      obj = TSeq.new(str)
+      val = obj.delete("g")
+      assert_instance_of(TSeq, val)
+      assert_equal(TSeq.new("atc"), val)
+    end
+
+    if "string".respond_to?(:delete_prefix)
+      def test_delete_prefix
+        str = "atgggc".freeze
+        obj = TSeq.new(str)
+        val = obj.delete_prefix("atg")
+        assert_instance_of(TSeq, val)
+        assert_equal(TSeq.new("ggc"), val)
+      end
+    end #if "string".respond_to?(:delete_prefix)
+
+
+    if "string".respond_to?(:delete_suffix)
+      def test_delete_suffix
+        str = "atgggc".freeze
+        obj = TSeq.new(str)
+        val = obj.delete_suffix("ggc")
+        assert_instance_of(TSeq, val)
+        assert_equal(TSeq.new("atg"), val)
+      end
+    end #if "string".respond_to?(:delete_suffix)
+
+    def test_each_char
+      str = 'atgc'.freeze
+      ary = str.split(//)
+      obj = TSeq.new(str)
+      obj.each_char do |c|
+        assert_instance_of(TSeq, c)
+        assert_equal(TSeq.new(ary.shift), c)
+      end
+    end
+
+    def test_each_char_enum
+      str = 'atgc'.freeze
+      ary = str.split(//).collect { |c| TSeq.new(c) }
+      obj = TSeq.new(str)
+      e = obj.each_char
+      to_a =  e.to_a
+      to_a.each { |c| assert_instance_of(TSeq, c) }
+      assert_equal(ary, to_a)
+    end
+
+    if "string".respond_to?(:each_grapheme_cluster)
+      def test_each_grapheme_cluster
+        str = 'atgc'.freeze
+        ary = str.split(//)
+        obj = TSeq.new(str)
+        obj.each_grapheme_cluster do |c|
+          assert_instance_of(TSeq, c)
+          assert_equal(TSeq.new(ary.shift), c)
+        end
+      end
+
+      def test_each_grapheme_cluster_enum
+        str = 'atgc'.freeze
+        ary = str.split(//).collect { |c| TSeq.new(c) }
+        obj = TSeq.new(str)
+        e = obj.each_grapheme_cluster
+        to_a =  e.to_a
+        to_a.each { |c| assert_instance_of(TSeq, c) }
+        assert_equal(ary, to_a)
+      end
+    end #if "string".respond_to?(:each_grapheme_cluster)
+
+    def test_each_line
+      str = "aagtcgt\nttgctagc\nggtacagt\n".freeze
+      ary = str.each_line.to_a
+      obj = TSeq.new(str)
+      obj.each_line do |c|
+        assert_instance_of(TSeq, c)
+        assert_equal(TSeq.new(ary.shift), c)
+      end
+    end
+
+    def test_each_line_enum
+      str = "aagtcgt\nttgctagc\nggtacagt\n".freeze
+      ary = str.each_line.collect { |x| TSeq.new(x) }
+      obj = TSeq.new(str)
+      e = obj.each_line
+      to_a =  e.to_a
+      to_a.each { |x| assert_instance_of(TSeq, x) }
+      assert_equal(ary, to_a)
+    end
+
+    def test_gsub
+      str = "aagtcgtaacaaggt".freeze
+      str2 = str.gsub(/aa/, "bb")
+      obj = TSeq.new(str)
+      val = obj.gsub(/aa/, "bb")
+      assert_instance_of(TSeq, val)
+      assert_equal(TSeq.new(str2), val)
+    end
+      
+    def test_sub
+      str = "aagtcgtaacaaggt".freeze
+      str2 = str.sub(/aa/, "bb")
+      obj = TSeq.new(str)
+      val = obj.sub(/aa/, "bb")
+      assert_instance_of(TSeq, val)
+      assert_equal(TSeq.new(str2), val)
+    end
+      
+    def test_gsub_with_block
+      str = "aagtcgtaacaaggtaagt".freeze
+      str2 = str.gsub(/a(ag)/) { |x| "bb" }
+      obj = TSeq.new(str)
+      val = obj.gsub(/a(ag)/) do |x|
+        assert_equal("ag", $1)
+        assert_equal("aag", $&)
+        assert_equal(TSeq.new("aag"), x)
+        assert_instance_of(MatchData, Regexp.last_match)
+        assert_instance_of(TSeq, x)
+        "bb"
+      end
+      assert_instance_of(TSeq, val)
+      assert_equal(TSeq.new(str2), val)
+    end
+
+    def test_sub_with_block
+      str = "aagtcgtaacaaggtaagt".freeze
+      str2 = str.sub(/a(ag)/) { |x| "bb" }
+      obj = TSeq.new(str)
+      val = obj.sub(/a(ag)/) do |x|
+        assert_equal("ag", $1)
+        assert_equal("aag", $&)
+        assert_equal(TSeq.new("aag"), x)
+        assert_instance_of(MatchData, Regexp.last_match)
+        assert_instance_of(TSeq, x)
+        "bb"
+      end
+      assert_instance_of(TSeq, val)
+      assert_equal(TSeq.new(str2), val)
+    end
+
+    def test_ljust
+      str = "atgc".freeze
+      str2 = str.ljust(20, "xyz")
+      obj = TSeq.new(str)
+      val = obj.ljust(20, "xyz")
+      assert_instance_of(TSeq, val)
+      assert_equal(TSeq.new(str2), val)
+    end
+
+    def test_rjust
+      str = "atgc".freeze
+      str2 = str.rjust(20, "xyz")
+      obj = TSeq.new(str)
+      val = obj.rjust(20, "xyz")
+      assert_instance_of(TSeq, val)
+      assert_equal(TSeq.new(str2), val)
+    end
+
+    def test_center
+      str = "atgc".freeze
+      str2 = str.center(20, "xyz")
+      obj = TSeq.new(str)
+      val = obj.center(20, "xyz")
+      assert_instance_of(TSeq, val)
+      assert_equal(TSeq.new(str2), val)
+    end
+
+    def test_strip
+      str = " at gc\n".freeze
+      str2 = str.strip
+      obj = TSeq.new(str)
+      val = obj.strip
+      assert_instance_of(TSeq, val)
+      assert_equal(TSeq.new(str2), val)
+    end
+ 
+    def test_lstrip
+      str = " at gc\n".freeze
+      str2 = str.lstrip
+      obj = TSeq.new(str)
+      val = obj.lstrip
+      assert_instance_of(TSeq, val)
+      assert_equal(TSeq.new(str2), val)
+    end
+
+    def test_rstrip
+      str = " at gc\n".freeze
+      str2 = str.rstrip
+      obj = TSeq.new(str)
+      val = obj.rstrip
+      assert_instance_of(TSeq, val)
+      assert_equal(TSeq.new(str2), val)
+    end
+
+    def test_split
+      str = "aagtcgta".freeze
+      ary = str.split("gt").collect { |x| TSeq.new(x) }
+      obj = TSeq.new(str)
+      val = obj.split("gt")
+      val.each do |x|
+        assert_instance_of(TSeq, x)
+      end
+      assert_equal(ary, val)
+    end
+
+    def test_reverse
+      str = "aagtttcca".freeze
+      str2 = str.reverse
+      obj = TSeq.new(str)
+      val = obj.reverse
+      assert_instance_of(TSeq, val)
+      assert_equal(TSeq.new(str2), val)
+    end
+
+    def test_squeeze
+      str = "aagtttcca".freeze
+      str2 = str.squeeze
+      obj = TSeq.new(str)
+      val = obj.squeeze
+      assert_instance_of(TSeq, val)
+      assert_equal(TSeq.new(str2), val)
+    end
+
+    def test_succ
+      str = "aagt".freeze
+      str2 = str.succ
+      obj = TSeq.new(str)
+      val = obj.succ
+      assert_instance_of(TSeq, val)
+      assert_equal(TSeq.new(str2), val)
+    end
+
+    def test_next
+      str = "aagt".freeze
+      str2 = str.next
+      obj = TSeq.new(str)
+      val = obj.next
+      assert_instance_of(TSeq, val)
+      assert_equal(TSeq.new(str2), val)
+    end
+
+    def test_capitalize
+      str = "aacgt".freeze
+      str2 = str.capitalize
+      obj = TSeq.new(str)
+      val = obj.capitalize
+      assert_instance_of(TSeq, val)
+      assert_equal(TSeq.new(str2), val)
+    end
+
+    def test_upcase
+      str = "aacgt".freeze
+      str2 = str.upcase
+      obj = TSeq.new(str)
+      val = obj.upcase
+      assert_instance_of(TSeq, val)
+      assert_equal(TSeq.new(str2), val)
+    end
+
+    def test_downcase
+      str = "AACGT".freeze
+      str2 = str.downcase
+      obj = TSeq.new(str)
+      val = obj.downcase
+      assert_instance_of(TSeq, val)
+      assert_equal(TSeq.new(str2), val)
+    end
+
+    def test_swapcase
+      str = "AaCgT".freeze
+      str2 = str.swapcase
+      obj = TSeq.new(str)
+      val = obj.swapcase
+      assert_instance_of(TSeq, val)
+      assert_equal(TSeq.new(str2), val)
+    end
+
+    def test_tr
+      str = "acggt".freeze
+      str2 = str.tr("cg", "xy")
+      obj = TSeq.new(str)
+      val = obj.tr("cg", "xy")
+      assert_instance_of(TSeq, val)
+      assert_equal(TSeq.new(str2), val)
+    end
+
+    def test_tr_s
+      str = "acggt".freeze
+      str2 = str.tr("cg", "n")
+      obj = TSeq.new(str)
+      val = obj.tr("cg", "n")
+      assert_instance_of(TSeq, val)
+      assert_equal(TSeq.new(str2), val)
+    end
+
+    def test_slice
+      str = "aagtcgta".freeze
+      str2 = str.slice(3, 3)
+      obj = TSeq.new(str)
+      val = obj.slice(3, 3)
+      assert_instance_of(TSeq, val)
+      assert_equal(TSeq.new(str2), val)
+    end
+
+    def test_slice2
+      str = "aagtcgta".freeze
+      str2 = str[3, 3]
+      obj = TSeq.new(str)
+      val = obj[3, 3]
+      assert_instance_of(TSeq, val)
+      assert_equal(TSeq.new(str2), val)
+    end
+  end #class TestSequenceCommon
+
+
+  class TestSequenceCommonPartition < Test::Unit::TestCase
+    def test_partition
+      str = "atgatgagttctattcatc".freeze
+      sep = "ttc".freeze
+      a0 = str.partition(sep)
+      a1 = [ TSeq.new(a0[0]), a0[1], TSeq.new(a0[2]) ]
+      obj = TSeq.new(str)
+      val = obj.partition(sep)
+      assert_instance_of(TSeq, val[0])
+      assert_instance_of(String, val[1])
+      assert_instance_of(TSeq, val[2])
+      assert_equal(a1, val)
+    end
+
+    def test_partition_sep_TSeq
+      str = "atgatgagttctattcatc".freeze
+      sep = TSeq.new("ttc").freeze
+      a0 = str.partition(sep)
+      a1 = [ TSeq.new(a0[0]), a0[1], TSeq.new(a0[2]) ]
+      obj = TSeq.new(str)
+      val = obj.partition(sep)
+      val.each { |x| assert_instance_of(TSeq, x) }
+      assert_equal(a1, val)
+    end
+
+    def test_partition_sep_regexp
+      str = "atgatgagttctattcatc".freeze
+      sep = /ttc/
+      a1 = str.partition(sep).collect { |x| TSeq.new(x) }
+      obj = TSeq.new(str)
+      val = obj.partition(sep)
+      val.each { |x| assert_instance_of(TSeq, x) }
+      assert_equal(a1, val)
+    end
+
+    def test_partition_nomatch
+      str = "atgatgagttctattcatc".freeze
+      sep = "x".freeze
+      a1 = str.partition(sep).collect { |x| TSeq.new(x) }
+      obj = TSeq.new(str)
+      val = obj.partition(sep)
+      val.each { |x| assert_instance_of(TSeq, x) }
+      assert_equal(a1, val)
+    end
+  end #class TestSequenceCommonPartition
+
+
+  class TestSequenceCommonRpartition < Test::Unit::TestCase
+    def test_rpartition
+      str = "atgatgagttctattcatc".freeze
+      sep = "ttc".freeze
+      a0 = str.rpartition(sep)
+      a1 = [ TSeq.new(a0[0]), a0[1], TSeq.new(a0[2]) ]
+      obj = TSeq.new(str)
+      val = obj.rpartition(sep)
+      assert_instance_of(TSeq, val[0])
+      assert_instance_of(String, val[1])
+      assert_instance_of(TSeq, val[2])
+      assert_equal(a1, val)
+    end
+
+    def test_rpartition_sep_TSeq
+      str = "atgatgagttctattcatc".freeze
+      sep = TSeq.new("ttc").freeze
+      a0 = str.rpartition(sep)
+      a1 = [ TSeq.new(a0[0]), a0[1], TSeq.new(a0[2]) ]
+      obj = TSeq.new(str)
+      val = obj.rpartition(sep)
+      val.each { |x| assert_instance_of(TSeq, x) }
+      assert_equal(a1, val)
+    end
+
+    def test_rpartition_sep_regexp
+      str = "atgatgagttctattcatc".freeze
+      sep = /ttc/
+      a1 = str.rpartition(sep).collect { |x| TSeq.new(x) }
+      obj = TSeq.new(str)
+      val = obj.rpartition(sep)
+      val.each { |x| assert_instance_of(TSeq, x) }
+      assert_equal(a1, val)
+    end
+
+    def test_rpartition_nomatch
+      str = "atgatgagttctattcatc".freeze
+      sep = "x".freeze
+      a1 = str.rpartition(sep).collect { |x| TSeq.new(x) }
+      obj = TSeq.new(str)
+      val = obj.rpartition(sep)
+      val.each { |x| assert_instance_of(TSeq, x) }
+      assert_equal(a1, val)
+    end
+  end #class TestSequenceCommonRpartition
+
+end; end #module Bio; module TestSequenceRuby3

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bio
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.0.3
 platform: ruby
 authors:
 - BioRuby project
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-31 00:00:00.000000000 Z
+date: 2021-11-05 00:00:00.000000000 Z
 dependencies: []
 description: BioRuby is a library for bioinformatics (biology + information science).
 email: staff@bioruby.org
@@ -557,6 +557,7 @@ files:
 - test/unit/bio/sequence/test_dblink.rb
 - test/unit/bio/sequence/test_na.rb
 - test/unit/bio/sequence/test_quality_score.rb
+- test/unit/bio/sequence/test_ruby3.rb
 - test/unit/bio/sequence/test_sequence_masker.rb
 - test/unit/bio/test_alignment.rb
 - test/unit/bio/test_command.rb
@@ -616,8 +617,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6.2
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Bioinformatics library