Newbie needs help

Hi everyone,

I’m new to Ruby and am encountering a problem with an error message that
I don’t quite understand. I am hoping someone more experienced can
explain where I have gone wrong. Any help would be much appreciated.

When I do not specify parameters, I get no errors:

ruby ~/Ruby_code/Align_against_reference.rb “temp.fastq”
“temp.alignment”
…done
Run options:

Running tests:

Finished tests in 0.007649s, 784.4163 tests/s, 6144.5941 assertions/s.

6 tests, 47 assertions, 0 failures, 0 errors, 0 skips

But when I specify which lines of the file to process, I get the
following:

ruby ~/Ruby_code/Align_against_reference.rb “temp.fastq”
“temp.alignment” 0 40
…done
/home/lok2/bin/ruby/lib/ruby/1.9.1/test/unit.rb:167:in block in non_options': file not found: 0 (ArgumentError) from /home/lok2/bin/ruby/lib/ruby/1.9.1/test/unit.rb:146:inmap!’
from /home/lok2/bin/ruby/lib/ruby/1.9.1/test/unit.rb:146:in
non_options' from /home/lok2/bin/ruby/lib/ruby/1.9.1/test/unit.rb:207:innon_options’
from /home/lok2/bin/ruby/lib/ruby/1.9.1/test/unit.rb:52:in
process_args' from /home/lok2/bin/ruby/lib/ruby/1.9.1/minitest/unit.rb:891:in_run’
from /home/lok2/bin/ruby/lib/ruby/1.9.1/minitest/unit.rb:884:in
run' from /home/lok2/bin/ruby/lib/ruby/1.9.1/test/unit.rb:21:inrun’
from /home/lok2/bin/ruby/lib/ruby/1.9.1/test/unit.rb:326:in
block (2 levels) in autorun' from /home/lok2/bin/ruby/lib/ruby/1.9.1/test/unit.rb:27:inrun_once’
from /home/lok2/bin/ruby/lib/ruby/1.9.1/test/unit.rb:325:in
`block in autorun’

My script:

require("/home/lok2/Ruby_code/SeqRead.rb")

start = ARGV[2].to_i
stop = ARGV[3].to_i == 0 ? :eof : ARGV[3].to_i

fastq = FastxReader.new
fastq.readSingleEnd(ARGV[0], start, stop)

pL = DNA.new(“TGC CGG AGT CAG CGT”) # 5’ -> 3’ left primer
pR = DNA.new(“AGT CAG AGT CGC CAC”) # 5’ -> 3’ right primer

sm = {
‘AA’ => 1, ‘AG’ => 0, ‘AC’ => 0, ‘AT’ => 0,
‘GA’ => 0, ‘GG’ => 1, ‘GC’ => 0, ‘GT’ => 0,
‘CA’ => 0, ‘CG’ => 0, ‘CC’ => 1, ‘CT’ => 0,
‘TA’ => 0, ‘TG’ => 0, ‘TC’ => 0, ‘TT’ => 1
}

insert =
DNA.new(“CTGTTCTCCCTACATCAAATGTCTATCCCCGCACCAAGTGGAGATTCCATGAGGATGAGG”)

def align(reference, test, similarity_matrix, gapPenality=0)
aln = NW.new(reference, test, similarity_matrix, gapPenality)
if (aln.score == reference.length)
return aln
else
aln2 = NW.new(reference, test.rev_comp.reverse, similarity_matrix,
gapPenality)
end
temp =(aln.score > aln2.score) ? aln : aln2
return(temp)
end

temp = File.open(ARGV[1], “w”)
alignments = fastq.reads.each do |read|
temp.puts “>” + read.readName
temp.puts “Sequence:”
temp.puts read.dna_seq
aln=align(insert, read.stripPrimers(pL, pR), sm, 0)
print “.”
temp.puts “Alignment:”
temp.puts aln.display
temp.puts “Errors:”
temp.puts aln.errors
temp.puts “\n”
end

Here are the relevant parts from SeqRead.rb

class FastxReader

attr_reader :reads, :type

def initialize(type=:fastq)
@type = type
@reads = []
end

def readSingleEnd (fastx_file, startline=0, endline=:eof)
file = File.open(fastx_file, “r”)
endline=File.foreach(fastx_file).inject(0){|c, l| c+1} if endline ==
:eof
(0…startline).each {|x| file.readline}
while file.lineno < endline && !file.eof? do
@reads << readRecord(file, @type)
end
file.close
end

def readPairedEnd (fastx_file_1, fastx_file_2)
fileA = File.open(fastx_file_1)
fileB = File.open(fastx_file_2)
while !fileA.eof? && !fileB.eof? do
readA = readRecord(fileA, @type)
readB = readRecord(fileB, @type)
@reads << PairedEndRead.new(readA, readB)
end
fileA.close
fileB.close
end

def readRecord(fastxFile, fileType=:fastq)
record = []
if fileType == :fastq
4.times {|x| record << fastxFile.gets.strip}
SeqRead.new(record[1], record[3], record[0].split("
").first).stripPrimer(“N”)
elsif filetype == :fasta
2.times {|x| record << fastxFile.gets.strip}
SeqRead.new(record[1], record[0]).stripPrimer(“N”)
else
throw ArgumentError
end
end

end

Where are your tests?

On Sep 5, 2012, at 09:33 , Ken L. [email protected] wrote:

ruby ~/Ruby_code/Align_against_reference.rb “temp.fastq”
“temp.alignment” 0 40
…done
/home/lok2/bin/ruby/lib/ruby/1.9.1/test/unit.rb:167:in `block in
non_options’: file not found: 0 (ArgumentError)

test/unit processes options on the command line so you can do things
like filter tests by regexps. You might be able to pass “–” before your
args to signal to it that you’re done passing it options.

Ryan D. wrote in post #1074855:

On Sep 5, 2012, at 09:33 , Ken L. [email protected] wrote:

ruby ~/Ruby_code/Align_against_reference.rb “temp.fastq”
“temp.alignment” 0 40
…done
/home/lok2/bin/ruby/lib/ruby/1.9.1/test/unit.rb:167:in `block in
non_options’: file not found: 0 (ArgumentError)

test/unit processes options on the command line so you can do things
like filter tests by regexps. You might be able to pass “–” before your
args to signal to it that you’re done passing it options.

When I do that, this is what I get:

ruby ~/Ruby_code/Align_against_reference.rb – temp.fastq temp.alignment
0 40

/home/lok2/Ruby_code/SeqRead.rb:99:in initialize': No such file or directory - -- (Errno::ENOENT) from /home/lok2/Ruby_code/SeqRead.rb:99:in open’
from /home/lok2/Ruby_code/SeqRead.rb:99:in readSingleEnd' from /home/lok2/Ruby_code/Align_against_reference.rb:8:in

7stud – wrote in post #1074810:

Where are your tests?

Here are my tests for the SeqRead class that I wrote.

require ‘test/unit’

class SeqReadTesting < Test::Unit::TestCase

def test_basic

seqRead1 = SeqRead.new(
  "AGTCAGAGTCGCCACCTGTTCTCCCTACATCAAATGTCTATCCCCGCACCAAGTGGAGATTCCATGAGGATGAGGACGCTGACTCCGGCAAGATCGGAAG",
  "@@@FFFFFHGHHHGHIGHHIIII+<9?CFCGF@B*111:?90*0?0@A--86(7@77@G#########################################",
  "@HWI-ST577:156:D16VVACXX:7:1101:1374:2212"
  )
pL = DNA.new("TGC CGG AGT CAG CGT") # 5' -> 3' left primer
pR = DNA.new("AGT CAG AGT CGC CAC") # 5' -> 3' right primer

assert_equal(seqRead1.dna_seq, seqRead1.stripPrimer(pR,

false).dna_seq)
assert_equal(seqRead1.dna_seq, seqRead1.stripPrimer(pL,
true).dna_seq)
assert_equal(seqRead1.qscore, seqRead1.stripPrimer(pR,
false).qscore)
assert_equal(seqRead1.qscore, seqRead1.stripPrimer(pL, true).qscore)

assert_equal("CTGTTCTCCCTACATCAAATGTCTATCCCCGCACCAAGTGGAGATTCCATGAGGATGAGGACGCTGACTCCGGCAAGATCGGAAG",
  seqRead1.stripPrimer(pR, true).dna_seq)
assert_equal("IGHHIIII+<9?CFCGF@B*111:?90*0?0@A--86(7@77@G#########################################",
  seqRead1.stripPrimer(pR, true).qscore)
assert_equal("AGTCAGAGTCGCCACCTGTTCTCCCTACATCAAATGTCTATCCCCGCACCAAGTGGAGATTCCATGAGGATGAGG",
  seqRead1.stripPrimer(pL, false).dna_seq)
assert_equal("@@@FFFFFHGHHHGHIGHHIIII+<9?CFCGF@B*111:?90*0?0@A--86(7@77@G################",
  seqRead1.stripPrimer(pL, false).qscore)

assert_equal("IGHHIIII+<9?CFCGF@B*111:?90*0?0@A--86(7@77@G################",
  seqRead1.stripPrimers(pL, pR).qscore)
assert_equal("CTGTTCTCCCTACATCAAATGTCTATCCCCGCACCAAGTGGAGATTCCATGAGGATGAGG",
  seqRead1.stripPrimers(pL, pR).dna_seq)

end

end

Here are my tests for the DNA class that I wrote. It is called from
SeqRead.rb

require ‘test/unit’

class DNATesting < Test::Unit::TestCase

def test_basic
@testBasic = DNA.new(“ACGTMKRYBVDHXN”)
assert_equal(“TGCAKMYRVBHDXN”, @testBasic.rev_comp.dna_seq)
assert_equal(“R”, @testBasic.rev_comp.direction)
assert_equal(“TGCAKMYRVBHDXN”, @testBasic.comp.dna_seq)
assert_equal(“F”, @testBasic.comp.direction)
end

def test_codons
@testCodons = DNA.new(“TTT TTT CTT ATC GTC GTC ATC TTT GTA GTC AGT
CAG AGT CGC CAC”)
assert_equal(“TTT TTT CTT ATC GTC GTC ATC TTT GTA GTC AGT CAG AGT
CGC CAC”,
@testCodons.split_by_codon(0))
assert_equal("T TTT TTC TTA TCG TCG TCA TCT TTG TAG TCA GTC AGA GTC
GCC AC ",
@testCodons.split_by_codon(1))
assert_equal("TT TTT TCT TAT CGT CGT CAT CTT TGT AGT CAG TCA GAG TCG
CCA C ",
@testCodons.split_by_codon(2))
assert_equal(“TTT TTT CTT ATC GTC GTC ATC TTT GTA GTC AGT CAG AGT
CGC CAC”,
@testCodons.split_by_codon(3))
end

def test_translation
@testTrans = DNA.new(“ATG GCG TGC CGT GAA TAG”)
assert_equal(“MACRE*”, @testTrans.translate(0, false).aa_seq)
assert_equal(“WRAVN”, @testTrans.translate(1, false).aa_seq)
assert_equal(“GVPI", @testTrans.translate(2, false).aa_seq)
assert_equal("MACRE
”, @testTrans.translate(3, false).aa_seq)
@testTrans2 = DNA.new(“GAT AAG TGC CGT GCG GTA”, “R”)
assert_equal(“MACRE*”, @testTrans2.translate(0, false).aa_seq)
assert_equal(“WRAVN”, @testTrans2.translate(1, false).aa_seq)
assert_equal(“GVPI", @testTrans2.translate(2, false).aa_seq)
assert_equal("MACRE
”, @testTrans2.translate(3, false).aa_seq)
end

def test_stripPrimers
@seq = DNA.new(“CCGCCCA AGACCC CGTACCGTTTGGCGTGTCGAGCCCG CTCATC
GGAATG”)
@seq1 = DNA.new(
“CCGCCCAAGACCCCGTACCGTTTGGCGTGTCGAGCCCGCTCATCGGAATG”)
@seq2 = DNA.new(
“AGACCCCGTACCGTTTGGCGTGTCGAGCCCGCTCATCGGAATG”)
@seq3 = DNA.new(
“GACCCCGTACCGTTTGGCGTGTCGAGCCCGCTCATCGGAATG”)
@seq4 = DNA.new(
“ACCCCGTACCGTTTGGCGTGTCGAGCCCGCTCATCGGAATG”)
@seq5 = DNA.new(
“CCCCGTACCGTTTGGCGTGTCGAGCCCGCTCATCGGAATG”)
@seq6 = DNA.new( “CCGCCCAAGACCCCGTACCGTTTGGCGTGTCGAGCCCGCTCATC”)
@seq7 = DNA.new( “CCGCCCAAGACCCCGTACCGTTTGGCGTGTCGAGCCCGCTCAT”)
@seq8 = DNA.new( “CCGCCCAAGACCCCGTACCGTTTGGCGTGTCGAGCCCGCTCA”)
@seq9 = DNA.new( “CCGCCCAAGACCCCGTACCGTTTGGCGTGTCGAGCCCGCTC”)
@seq10 = DNA.new(“GTA AGG CTA CTC GCC CGA GCT GTG CGG TTT GCC ATG
CCC CAG AAC CCG”, “R”)

@primer_for = DNA.new("AGACCC")   # 5' -> 3'
@primer_rev = DNA.new("GATGAG")   # 5' -> 3'

assert_equal("CGTACCGTTTGGCGTGTCGAGCCCG",

@seq.stripPrimers(@primer_for, @primer_rev).dna_seq)
assert_equal(“CGTACCGTTTGGCGTGTCGAGCCCG”,
@seq10.stripPrimers(@primer_for, @primer_rev).dna_seq)
assert_equal(“CGTACCGTTTGGCGTGTCGAGCCCG”,
@seq1.stripPrimers(@primer_for, @primer_rev).dna_seq)
assert_equal(“CGTACCGTTTGGCGTGTCGAGCCCG”,
@seq2.stripPrimers(@primer_for, @primer_rev).dna_seq)
assert_equal(“CGTACCGTTTGGCGTGTCGAGCCCG”,
@seq3.stripPrimers(@primer_for, @primer_rev).dna_seq)
assert_equal(“ACCCCGTACCGTTTGGCGTGTCGAGCCCG”,
@seq4.stripPrimers(@primer_for, @primer_rev).dna_seq)
assert_equal(“CCCCGTACCGTTTGGCGTGTCGAGCCCG”,
@seq5.stripPrimers(@primer_for, @primer_rev).dna_seq)
assert_equal(“CGTACCGTTTGGCGTGTCGAGCCCG”,
@seq6.stripPrimers(@primer_for, @primer_rev).dna_seq)
assert_equal(“CGTACCGTTTGGCGTGTCGAGCCCG”,
@seq7.stripPrimers(@primer_for, @primer_rev).dna_seq)
assert_equal(“CGTACCGTTTGGCGTGTCGAGCCCGCTCA”,
@seq8.stripPrimers(@primer_for, @primer_rev).dna_seq)
assert_equal(“CGTACCGTTTGGCGTGTCGAGCCCGCTC”,
@seq9.stripPrimers(@primer_for, @primer_rev).dna_seq)

@primer_for = DNA.new("")
assert_equal("CCCCGTACCGTTTGGCGTGTCGAGCCCGCTCATCGGAATG",

@seq5.stripPrimer(@primer_for, true).dna_seq)
end
end

class PeptideTesting < Test::Unit::TestCase

def test_private_combination
a = [“A”,“B”]
b = [“C”,“D”]
c = [“E”]
d = “F”
e = []
temp = Peptide.new(“MACRE”)
assert_equal([[“A”,“C”],[“B”,“C”],[“A”,“D”],[“B”,“D”]],
temp.send(:combination, a, b))
assert_equal([[“C”,“A”],[“D”,“A”],[“C”,“B”],[“D”,“B”]],
temp.send(:combination, b, a))
assert_equal([[“A”,“E”],[“B”,“E”]],
temp.send(:combination, a, c))
assert_equal([[“E”,“A”],[“E”,“B”]],
temp.send(:combination, c, a))
assert_equal([[“A”,“F”],[“B”,“F”]],
temp.send(:combination, a, d))
assert_equal([[“F”,“A”],[“F”,“B”]],
temp.send(:combination, d, a))
assert_equal([[“E”]], temp.send(:combination, e, c))
assert_equal([[“E”]], temp.send(:combination, c, e))
assert_equal(temp.send(:combination, d, e),
temp.send(:combination, e, d))
end
end

What is really weird to me is that the problem only shows itself when I
specify the range of lines to use. When I do this,

ruby ~/Ruby_code/SeqRead.rb

Run options:

Running tests:

Finished tests in 0.013596s, 441.3063 tests/s, 3456.8991 assertions/s.

6 tests, 47 assertions, 0 failures, 0 errors, 0 skips

or

ruby ~/Ruby_code/DNA_Class.rb

Run options:

Running tests:

Finished tests in 0.005082s, 983.8646 tests/s, 7280.5982 assertions/s.

5 tests, 37 assertions, 0 failures, 0 errors, 0 skips

So it seems that the classes are ok, just somehow interacting with ARGV
gives me a problem. I am so lost.

Thanks for helping!

Thanks Ryan, I’ll try that out.

On Sep 5, 2012, at 15:30 , Ken L. [email protected] wrote:

like filter tests by regexps. You might be able to pass “–” before your
from /home/lok2/Ruby_code/SeqRead.rb:99:in readSingleEnd' from /home/lok2/Ruby_code/Align_against_reference.rb:8:in

Then it looks like you can’t do that. Don’t depend on ARGV. Wrap your
code under test up into a method and pass ARGV in as an argument from a
driver file. Then your tests can pass in whatever they want.