From 2971b6784ab7a0fde6e3057e03bc6c41aa41e062 Mon Sep 17 00:00:00 2001
From: martinahansen <martinahansen@74ccb610-7750-0410-82ae-013aeee3265d>
Date: Wed, 1 Jul 2009 10:11:34 +0000
Subject: [PATCH] changed seq_type from string to symbols in ruby

git-svn-id: http://biopieces.googlecode.com/svn/trunk@550 74ccb610-7750-0410-82ae-013aeee3265d
---
 code_ruby/Maasha/lib/seq.rb       | 26 +++++++--------
 code_ruby/Maasha/test/test_seq.rb | 55 ++++++++++++++++---------------
 2 files changed, 40 insertions(+), 41 deletions(-)

diff --git a/code_ruby/Maasha/lib/seq.rb b/code_ruby/Maasha/lib/seq.rb
index da28e10..ba79c85 100644
--- 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 35565f1..7ec47ec 100755
--- 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
 
-- 
2.39.5