changed seq_type from string to symbols in ruby

git-svn-id: http://biopieces.googlecode.com/svn/trunk@550 74ccb610-7750-0410-82ae-013aeee3265d

diff --git a/code_ruby/Maasha/lib/seq.rb b/code_ruby/Maasha/lib/seq.rb
index da28e104c704387eab9cbc60bebdb460ea3042d5..ba79c85cd31f729caaa2dbaff67c38dde02eff90 100644 (file)
--- a/code_ruby/Maasha/lib/seq.rb
+++ b/code_ruby/Maasha/lib/seq.rb
@@ -13,11 +13,11 @@ class Seq < String
                seq_beg = @seq[ 0, 100 ].upcase
 
                if seq_beg.count( "FLPQIE" ) > 0
-                       "AA"
+                       :AA
                elsif seq_beg.count( "U" ) > 0
-                       "RNA"
+                       :RNA
                else
-                       "DNA"
+                       :DNA
                end
        end
 
@@ -28,16 +28,14 @@ class Seq < String
 
        # Method that return an array of the residue alphabet for a given sequence type.
        def seq_alph( seq_type )
-               case seq_type.upcase
-               when 'DNA'
-                       %w{ A T C G }
-               when 'RNA'
-                       %w{ A U C G }
-               when 'AA'
-                       %w{ F L S Y C W P H Q R I M T N K V A D E G }
-               else
-                       raise "ERROR: Sequence type '#{ seq_type }' not recognized."
-               end
+               hash = {
+                       :DNA => %w{ A T C G },
+                       :RNA => %w{ A U C G },
+                       :AA  => %w{ F L S Y C W P H Q R I M T N K V A D E G },
+               }
+
+               raise "ERROR: Sequence type '#{ seq_type }' not recognized." unless hash.include?( seq_type )
+               return hash[ seq_type ]
        end
 
        # Method to wrap a sequence to a given width using a given delimiter.
@@ -72,7 +70,7 @@ class Seq < String
                # Method to initialize a new amino acid sequence.
                def initialize( seq = "" )
                        @seq      = seq
-                       @seq_type = "AA"
+                       @seq_type = :AA
                end
 
                # Calculate the molecular weight of an amino acid seuqunce.

diff --git a/code_ruby/Maasha/test/test_seq.rb b/code_ruby/Maasha/test/test_seq.rb
index 35565f1d37fbf074d6a0bf8f6408c645469cc609..7ec47ecc9ed3cbbd531d6787e1d2c2c659eef8c7 100755 (executable)
--- a/code_ruby/Maasha/test/test_seq.rb
+++ b/code_ruby/Maasha/test/test_seq.rb
@@ -7,22 +7,25 @@ class TestSeq < Test::Unit::TestCase
 
        # Testing Seq#initialize
 
+       # test marked for deletion - too simple and informative
        def test_Seq_initialize_with_0_args
                s = Seq.new
                assert_equal( "", s.seq ) 
                assert_equal( nil, s.seq_type ) 
        end
 
+       # test marked for deletion - too simple and informative
        def test_Seq_initialize_with_1_args
                s = Seq.new( "ATCG" )
                assert_equal( "ATCG", s.seq ) 
                assert_equal( nil,    s.seq_type )
        end
 
+       # test marked for deletion - too simple and informative
        def test_Seq_initialize_with_2_args
-               s = Seq.new( "ATCG", "DNA" )
+               s = Seq.new( "ATCG", :DNA )
                assert_equal( "ATCG", s.seq ) 
-               assert_equal( "DNA", s.seq_type ) 
+               assert_equal( :DNA, s.seq_type ) 
        end 
 
        # Testing Seq#seq_type_guess
@@ -30,34 +33,33 @@ class TestSeq < Test::Unit::TestCase
        def test_seq_type_guess_DNA_uppercase
                s = Seq.new( "ATCG" )
 
-               assert_equal( "DNA", s.seq_type_guess )
+               assert_equal( :DNA, s.seq_type_guess )
        end
 
        def test_seq_type_guess_DNA_lowercase
                s = Seq.new( "atcg" )
 
-               assert_equal( "DNA", s.seq_type_guess )
+               assert_equal( :DNA, s.seq_type_guess )
        end
 
        def test_seq_type_guess_RNA_uppercase
                s = Seq.new( "AUCG" )
-               assert_equal( "RNA", s.seq_type_guess )
+               assert_equal( :RNA, s.seq_type_guess )
        end
 
        def test_seq_type_guess_RNA_lowercase
                s = Seq.new( "aucg" )
-               assert_equal( "RNA", s.seq_type_guess )
+               assert_equal( :RNA, s.seq_type_guess )
        end
 
        def test_seq_type_guess_AA_uppercase
                s = Seq.new( "SEQ" )
-               assert_equal( "AA", s.seq_type_guess )
+               assert_equal( :AA, s.seq_type_guess )
        end
 
        def test_seq_type_guess_AA_lowercase
                s = Seq.new( "seq" )
-               assert_equal( "AA", s.seq_type_guess )
-               assert_equal( nil, s.seq_type )
+               assert_equal( :AA, s.seq_type_guess )
        end
 
        def test_seq_type_guess_dont_change_instance_var
@@ -71,37 +73,37 @@ class TestSeq < Test::Unit::TestCase
        def test_seq_type_guess_DNA_uppercase!
                s = Seq.new( "ATCG" )
                s.seq_type_guess!
-               assert_equal( "DNA", s.seq_type )
+               assert_equal( :DNA, s.seq_type )
        end
 
        def test_seq_type_guess_DNA_lowercase!
                s = Seq.new( "atcg" )
                s.seq_type_guess!
-               assert_equal( "DNA", s.seq_type )
+               assert_equal( :DNA, s.seq_type )
        end
 
        def test_seq_type_guess_RNA_uppercase!
                s = Seq.new( "AUCG" )
                s.seq_type_guess!
-               assert_equal( "RNA", s.seq_type )
+               assert_equal( :RNA, s.seq_type )
        end
 
        def test_seq_type_guess_RNA_lowercase!
                s = Seq.new( "aucg" )
                s.seq_type_guess!
-               assert_equal( "RNA", s.seq_type )
+               assert_equal( :RNA, s.seq_type )
        end
 
        def test_seq_type_guess_AA_uppercase!
                s = Seq.new( "SEQ" )
                s.seq_type_guess!
-               assert_equal( "AA", s.seq_type )
+               assert_equal( :AA, s.seq_type )
        end
 
        def test_seq_type_guess_AA_lowercase!
                s = Seq.new( "seq" )
                s.seq_type_guess!
-               assert_equal( "AA", s.seq_type )
+               assert_equal( :AA, s.seq_type )
        end
 
        # Testing Seq#seq_alph
@@ -109,28 +111,25 @@ class TestSeq < Test::Unit::TestCase
        def test_seq_alph_DNA
                s = Seq.new
 
-               assert_equal( %w{ A T C G }, s.seq_alph( "DNA" ) )
-               assert_equal( %w{ A T C G }, s.seq_alph( "dna" ) )
+               assert_equal( %w{ A T C G }, s.seq_alph( :DNA ) )
        end
 
        def test_seq_alph_RNA
                s = Seq.new
 
-               assert_equal( %w{ A U C G }, s.seq_alph( "RNA" ) )
-               assert_equal( %w{ A U C G }, s.seq_alph( "rna" ) )
+               assert_equal( %w{ A U C G }, s.seq_alph( :RNA ) )
        end
 
        def test_seq_alph_AA
                s = Seq.new
 
-               assert_equal( %w{ F L S Y C W P H Q R I M T N K V A D E G }, s.seq_alph( "AA" ) )
-               assert_equal( %w{ F L S Y C W P H Q R I M T N K V A D E G }, s.seq_alph( "aa" ) )
+               assert_equal( %w{ F L S Y C W P H Q R I M T N K V A D E G }, s.seq_alph( :AA ) )
        end
 
        def test_seq_alph_invalid
                s = Seq.new
 
-               assert_raise( RuntimeError ) { s.seq_alph( "protein" )}
+               assert_raise( RuntimeError ) { s.seq_alph( "DNA" ) } # seq_alph wants a symbol
        end
 
        # Testing Seq#wrap
@@ -216,7 +215,7 @@ class TestSeq < Test::Unit::TestCase
        end
 
        def test_generate
-               s = Seq.new( "", "AA" )
+               s = Seq.new( "", :AA )
 
                seq = s.generate( 40 )
 
@@ -224,7 +223,7 @@ class TestSeq < Test::Unit::TestCase
        end
 
        def test_generate_dont_change_instance_var
-               s = Seq.new( "", "AA" )
+               s = Seq.new( "", :AA )
 
                seq = s.generate( 40 )
 
@@ -234,7 +233,7 @@ class TestSeq < Test::Unit::TestCase
        # Testing Seq#generate!
 
        def test_generate!
-               s = Seq.new( "", "AA" )
+               s = Seq.new( "", :AA )
 
                gen_seq = s.generate!( 40 )
 
@@ -245,16 +244,18 @@ class TestSeq < Test::Unit::TestCase
 
        # Testing Seq::AA#initialize
 
+       # test marked for deletion - too simple and informative
        def test_Seq_AA_initialize_with_0_args
                s = Seq::AA.new
                assert_equal( "", s.seq )
-               assert_equal( "AA", s.seq_type )
+               assert_equal( :AA, s.seq_type )
        end
 
+       # test marked for deletion - too simple and informative
        def test_Seq_AA_initialize_with_1_args
                s = Seq::AA.new( "SEQ" )
                assert_equal( "SEQ", s.seq )
-               assert_equal( "AA",  s.seq_type )
+               assert_equal( :AA,  s.seq_type )
        end
 end