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:in
`map!'
        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:in
`non_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:in `run'
        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:in
`run_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

···

--
Posted via http://www.ruby-forum.com/.

Where are your tests?

···

--
Posted via http://www.ruby-forum.com/.

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.

···

On Sep 5, 2012, at 09:33 , Ken L. <lists@ruby-forum.com> 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)

Thanks Ryan, I'll try that out.

···

--
Posted via http://www.ruby-forum.com/.

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("GVP*I", @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("GVP*I", @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!

···

--
Posted via http://www.ruby-forum.com/.

Ryan Davis wrote in post #1074855:

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
`<main>'

···

On Sep 5, 2012, at 09:33 , Ken L. <lists@ruby-forum.com> wrote:

--
Posted via http://www.ruby-forum.com/.

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.

···

On Sep 5, 2012, at 15:30 , Ken L. <lists@ruby-forum.com> wrote:

Ryan Davis wrote in post #1074855:

On Sep 5, 2012, at 09:33 , Ken L. <lists@ruby-forum.com> 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
`<main>'