scaffolder 0.2.6 → 0.4.0

data/test/test_scaffolder.rb

@@ -2,83 +2,114 @@ require 'helper'
 
 class TestScaffolder < Test::Unit::TestCase
   context Scaffolder do
-    
+
+    Scaffolder::Region::Mock = Class.new(Scaffolder::Region)
+
     setup do
-      @sequence = File.join(File.dirname(__FILE__),'data','sequences.fna')
-        @assembly = [ {"sequence" => { "source" => "sequence1" } } ]
-        @expect = {:name => 'sequence1', :start => nil, :end => nil,
-          :sequence => 'ATGCCAGATAACTGACTAGCATG', :reverse => nil}
+      @sequence = nil
+      @data = [{'mock' => Hash.new}]
     end
 
-    context "when parsing a sequence tag" do
+    context 'parsing a scaffold file' do
 
-      should "create sequence" do
-        mock(Scaffolder::Sequence).new(@expect)
-        Scaffolder.new @assembly, @sequence
+      setup do
+        Bio::FlatFile.stubs(:auto).with(@sequence).returns({})
       end
 
-      should "create sequence with coordinates" do
-        @assembly.first['sequence'].update('start' => 2, 'end' => 5)
-        mock(Scaffolder::Sequence).new(@expect.update({:start => 2, :end => 5 }))
-        Scaffolder.new @assembly, @sequence
+      should "fetch correct region class type" do
+        Scaffolder::Region.expects(:'[]').with('mock').returns(Scaffolder::Region::Mock)
+        Scaffolder.new(@data,@sequence)
       end
 
-      should "create sequence with reverse" do
-        @assembly.first['sequence'].update('reverse' => true)
-        mock(Scaffolder::Sequence).new(@expect.update({:reverse => true }))
-        Scaffolder.new @assembly, @sequence
+      should "pass data to region object" do
+        Scaffolder::Region::Mock.expects(:generate).with(@data.first['mock'])
+        Scaffolder.new(@data,@sequence)
       end
 
-      should "throw an error when source doesn't have a matching sequence" do
-        @assembly.first['sequence'].update('source' => 'sequence3')
-        assert_raise(ArgumentError){ Scaffolder.new @assembly, @sequence }
-      end
     end
 
-    context "parsing an assembly with sequence inserts" do
+    context 'parsing a scaffold file with a source keyword' do
 
       setup do
-        @assembly.first['sequence'].update({"inserts" => [{
-          "source" => "insert1", "start" => 5, "stop" => 10, "reverse" => true
-        }]})
+        Bio::FlatFile.stubs(:auto).with(@sequence).returns([
+          stub(:definition => 'seq1', :seq => 'ATGC')])
+      end
+
+      should "should also pass raw_sequence from flat file" do
+        @data.first['mock']['source'] = 'seq1'
+        Scaffolder::Region::Mock.any_instance.expects(:source).with('seq1')
+        Scaffolder::Region::Mock.any_instance.expects(:raw_sequence).with('ATGC')
+        Scaffolder.new(@data,@sequence)
       end
 
-      should "pass inserts to sequence object" do
-        params = {:start => 5, :stop => 10,
-          :sequence => 'GGTAGTA', :reverse => true}
+    end
 
-        insert = Scaffolder::Insert.new(params)
+    context 'updating each data hash with raw_sequence attributes' do
 
-        mock.instance_of(Scaffolder::Sequence).add_inserts([insert])
-        mock(Scaffolder::Insert).new(params){insert}
+      setup do
+        @seqs = {'seq1' => 'AAA'}
+        @expected = {'source' => 'seq1', 'raw_sequence' => @seqs['seq1']}
+      end
 
-        Scaffolder.new @assembly, @sequence
+      should "do nothing when no source keyword" do
+        test = {'something' => 'nothing'}
+        assert_equal(test,Scaffolder.update_with_sequence(test,@seqs))
       end
 
-      should "throw and error when insert does not have a matching sequence" do
-        @assembly.first['sequence']['inserts'].first.update({
-          "source" => "missing"})
-        assert_raise(ArgumentError){ Scaffolder.new @assembly, @sequence }
+      should "add raw_sequence to simple hash" do
+        test = {'source' => 'seq1'}
+        assert_equal(@expected,Scaffolder.update_with_sequence(test,@seqs))
       end
 
-    end
+      should "add raw_sequence to a nested hash" do
+        test     = {'something' => {'source' => 'seq1'}}
+        expected = {'something' => @expected}
+        assert_equal(expected,Scaffolder.update_with_sequence(test,@seqs))
+      end
 
-    context "when parsing an assembly with an unresolved region" do
+      should "add raw_sequence to a twice nested hash" do
+        test     = {'something' => {'other' => {'source' => 'seq1'}}}
+        expected = {'something' => {'other' => @expected}}
+        assert_equal(expected,Scaffolder.update_with_sequence(test,@seqs))
+      end
 
-      setup{ @assembly = [ {"unresolved" => { "length" => 5 } } ] }
+      should "add raw_sequence to simple hash inside an array" do
+        test     = [{'source' => 'seq1'}]
+        expected = [@expected]
+        assert_equal(expected,Scaffolder.update_with_sequence(test,@seqs))
+      end
 
-      should 'create an unresolved region' do
-        mock(Scaffolder::Region).new(:unresolved,'N'*5)
-        Scaffolder.new @assembly, @sequence
+      should "add raw_sequence to a nested hash inside an array" do
+        test     = {'something' => [{'source' => 'seq1'}]}
+        expected = {'something' => [@expected]}
+        assert_equal(expected,Scaffolder.update_with_sequence(test,@seqs))
       end
 
-    end
+      should "add raw_sequence to two nested hashes inside an array" do
+        test     = {'something' => [{'source' => 'seq1'},{'source' => 'seq1'}]}
+        expected = {'something' => [@expected,@expected]}
+        assert_equal(expected,Scaffolder.update_with_sequence(test,@seqs))
+      end
 
-    context "when parsing an unknown tag" do
-      setup{ @assembly = [{'non_standard_tag' => []}] }
-      should "throw an argument error" do
-        assert_raise(ArgumentError){ Scaffolder.new @assembly, @sequence }
+      should "add raw_sequence to a hash inside a hash inside an array" do
+        test     = {'something' => [{'else' => {'source' => 'seq1'}}]}
+        expected = {'something' => [{'else' => @expected}]}
+        assert_equal(expected,Scaffolder.update_with_sequence(test,@seqs))
       end
+
+      should "add raw_sequence to a twice nested (hash inside an array)" do
+        test     = {'something' => [{'else' => [{'source' => 'seq1'}]}]}
+        expected = {'something' => [{'else' => [@expected]}]}
+        assert_equal(expected,Scaffolder.update_with_sequence(test,@seqs))
+      end
+
+      should "throw an UnknownSequenceError when no matching sequence" do
+        test = {'source' => 'non_existent_sequence'}
+        assert_raise(Scaffolder::Errors::UnknownSequenceError) do
+          Scaffolder.update_with_sequence(test,@seqs)
+        end
+      end
+
     end
 
   end

data/test/test_sequence.rb

@@ -1,122 +1,99 @@
 require 'helper'
 
-class TestScaffolder < Test::Unit::TestCase
-  context Scaffolder::Sequence do
+class TestSequence < Test::Unit::TestCase
+  context Scaffolder::Region::Sequence do
 
-    setup do
-      @options = { :name => "sequence1",
-        :sequence => 'ATGCCAGATAACTGACTAGCATG' }
+    context "attributes" do
+      should_have_method_attribute Scaffolder::Region::Sequence
+      should_have_attribute Scaffolder::Region::Sequence, :source, :inserts
     end
 
-    context "processing a simple sequence tag" do
+    context "insert attribute method" do
 
-      should "create sequence object" do
-        sequence = Scaffolder::Sequence.new @options
-        assert_equal(sequence.entry_type,:sequence)
-        assert_equal(sequence.start,1)
-        assert_equal(sequence.end,23)
-        assert_equal(sequence.name,'sequence1')
-        assert_equal(sequence.sequence,'ATGCCAGATAACTGACTAGCATG')
-        assert_equal(sequence.raw_sequence,'ATGCCAGATAACTGACTAGCATG')
+      setup do
+        @sequence = Scaffolder::Region::Sequence.new
+        @hash = {'open' => 2, 'close' => 3}
+        @insert = Scaffolder::Region::Insert.new
+        @insert.open  @hash['open']
+        @insert.close @hash['close']
       end
 
-      should "reverse sequence when passed the reverse option" do
-        sequence = Scaffolder::Sequence.new @options.merge(:reverse => true)
-        assert_equal(sequence.sequence,'CATGCTAGTCAGTTATCTGGCAT')
-        assert_equal(sequence.raw_sequence,'ATGCCAGATAACTGACTAGCATG')
+      should "return empty array as default value" do
+        assert_equal(@sequence.inserts,Array.new)
       end
 
-      should "create subsequence object when passed sequence coordinates" do
-        sequence = Scaffolder::Sequence.new @options.merge(:start => 5,:end => 20)
-        assert_equal(sequence.start,5)
-        assert_equal(sequence.end,20)
-        assert_equal(sequence.sequence,'CAGATAACTGACTAGC')
+      should "allow array of inserts to be set as value" do
+        @sequence.inserts [@insert]
+        assert_equal(@sequence.inserts,[@insert])
       end
 
-      should "throw an error when the start position is outside the sequence length" do
-        begin
-          Scaffolder::Sequence.new @options.merge(:start => 0)
-          flunk "Should throw an argument error"
-        rescue ArgumentError
-        end
+      should "process insert data hash into an array of inserts" do
+        @sequence.inserts [@hash]
+        insert = @sequence.inserts.first
+        assert_instance_of(Scaffolder::Region::Insert,insert)
+        assert_equal(@hash['close'],insert.close)
+        assert_equal(@hash['open'],insert.open)
       end
 
-      should "throw an error when the end position is outside the sequence length" do
-        begin
-          Scaffolder::Sequence.new @options.merge(:end => 24)
-          flunk "Should throw an argument error"
-        rescue ArgumentError
-        end
-      end
-
-      should "throw an error when the start is greater than the end" do
-        begin
-          Scaffolder::Sequence.new @options.merge(:end => 5,:start => 10)
-          flunk "Should throw an argument error"
-        rescue ArgumentError
+      should "process mixed insert data into an array of inserts" do
+        @sequence.inserts [@hash,@insert]
+        @sequence.inserts.each do |insert|
+          assert_instance_of(Scaffolder::Region::Insert,insert)
+          assert_equal(@hash['close'],insert.close)
+          assert_equal(@hash['open'],insert.open)
         end
       end
 
     end
 
-    context "processing a sequence tag with inserts" do
+    context "with inserts added" do
 
       setup do
-        @insert = {:start => 5, :stop => 10, :sequence => 'GGTAGTA'}
-        @sequence = Scaffolder::Sequence.new @options
-      end
+        @sequence = Scaffolder::Region::Sequence.new
+        @sequence.raw_sequence 'ATGCCAGATAACTGACTAGCATG'
 
-      should "raise when the insert start is after the sequence end" do
-        @insert.update(:start => 24,:stop => nil)
-        assert_raise(ArgumentError) do
-          @sequence.add_inserts([Scaffolder::Insert.new @insert])
-        end
+        @insert = Scaffolder::Region::Insert.new
+        @insert.raw_sequence 'GGTAGTA'
+        @insert.open  5
+        @insert.close 10
       end
 
-      should "raise when the insert stop is before the sequence start" do
-        @insert.update(:start => -5,:stop => 0)
-        assert_raise(ArgumentError) do
-          @sequence.add_inserts([Scaffolder::Insert.new @insert])
-        end
-      end
-
-      should "raise when insert start is greater than end" do
-        @insert.update(:start => 11)
-        assert_raise(ArgumentError) do
-          @sequence.add_inserts([Scaffolder::Insert.new @insert])
-        end
+      should "raise when the insert open is after the sequence stop" do
+        @insert.open 24
+        @insert.close 25
+        @sequence.inserts [@insert]
+        assert_raise(Scaffolder::Errors::CoordinateError){ @sequence.sequence }
       end
 
-      should "update the sequence" do
-        @sequence.add_inserts([Scaffolder::Insert.new @insert])
-        assert_equal(@sequence.sequence,'ATGCGGTAGTAACTGACTAGCATG')
-        assert_equal(@sequence.end,24)
-        assert_equal(@sequence.raw_sequence,'ATGCCAGATAACTGACTAGCATG')
+      should "raise when the insert close is before the sequence start" do
+        @insert.open -5
+        @insert.close 0
+        @sequence.inserts [@insert]
+        assert_raise(Scaffolder::Errors::CoordinateError){ @sequence.sequence }
       end
 
-      should "return added insert as an attribute" do
-        inserts = [Scaffolder::Insert.new @insert]
-        @sequence.add_inserts(inserts)
-        assert_equal(@sequence.inserts,inserts)
+      should "raise when the insert open is greater than the insert close" do
+        @insert.open 11
+        @sequence.inserts [@insert]
+        assert_raise(Scaffolder::Errors::CoordinateError){ @sequence.sequence }
       end
 
-      should "return empty array when no inserts and inserts method called" do
-        assert_equal(@sequence.inserts,[])
+      should "update the sequence with a simple insert" do
+        @sequence.inserts [@insert]
+        assert_equal(@sequence.sequence,'ATGCGGTAGTAACTGACTAGCATG')
       end
 
-      should "update the sequence when reversed" do
-        @sequence = Scaffolder::Sequence.new @options.update(:reverse => true)
-        @sequence.add_inserts([Scaffolder::Insert.new @insert])
-        assert_equal(@sequence.sequence,"CATGCTAGTCAGTTACTACCGCAT")
-        assert_equal(@sequence.raw_sequence,'ATGCCAGATAACTGACTAGCATG')
+      should "update the sequence stop position after adding a simple insert" do
+        @sequence.inserts [@insert]
+        assert_equal(@sequence.stop,24)
       end
 
-      should "update the sequence with two inserts" do
-        @sequence.add_inserts([Scaffolder::Insert.new(@insert),
-          Scaffolder::Insert.new(@insert.update(:start => 12, :stop => 15))])
+      should "update sequence with inserts in reverse order" do
+        insert_two = @insert.clone
+        insert_two.open 12
+        insert_two.close 15
+        @sequence.inserts [@insert,insert_two]
         assert_equal(@sequence.sequence,"ATGCGGTAGTAAGGTAGTACTAGCATG")
-        assert_equal(@sequence.end,27)
-        assert_equal(@sequence.raw_sequence,'ATGCCAGATAACTGACTAGCATG')
       end
     end
 

data/test/test_unresolved.rb

@@ -0,0 +1,23 @@
+require 'helper'
+
+class TestScaffolder < Test::Unit::TestCase
+  context Scaffolder::Region::Unresolved do
+
+    should_have_method_attribute Scaffolder::Region::Unresolved
+    should_have_attribute Scaffolder::Region::Unresolved, :length
+
+    should "return unresolved sequence when given length" do
+      length = 5
+      unresolved = Scaffolder::Region::Unresolved.new
+      unresolved.length length
+      assert_equal(unresolved.sequence,'N' * 5)
+    end
+
+    should "raise an error if length is unspecified" do
+      assert_raise(Scaffolder::Errors::CoordinateError) do 
+        Scaffolder::Region::Unresolved.new.sequence
+      end
+    end
+
+  end
+end

data/yard/attribute_handler.rb

@@ -0,0 +1,12 @@
+class AttributeHander < YARD::Handlers::Ruby::Legacy::Base
+  handles /\Aattribute\b/
+  namespace_only
+
+  def process
+    name = statement.tokens[2].text.gsub(':','')
+    object = YARD::CodeObjects::MethodObject.new(namespace, name)
+    register(object)
+    object.dynamic = true
+  end
+
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: scaffolder
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 15
   prerelease: false
   segments: 
   - 0
-  - 2
-  - 6
-  version: 0.2.6
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Michael Barton
@@ -15,82 +15,130 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-10 00:00:00 -04:00
+date: 2011-01-04 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: bio
-  prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 7
         segments: 
-        - 0
-        version: "0"
+        - 1
+        - 4
+        version: "1.4"
   type: :runtime
+  name: bio
+  prerelease: false
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: rr
-  prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: 33
+        hash: 15
         segments: 
+        - 1
         - 0
-        - 10
-        - 11
-        version: 0.10.11
+        version: "1.0"
   type: :development
+  name: bundler
+  prerelease: false
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: shoulda
-  prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 21
         segments: 
-        - 0
-        version: "0"
+        - 2
+        - 11
+        version: "2.11"
   type: :development
+  name: shoulda
+  prerelease: false
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: redgreen
-  prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 25
         segments: 
         - 0
-        version: "0"
+        - 9
+        version: "0.9"
   type: :development
+  name: mocha
+  prerelease: false
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: yard
-  prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 7
         segments: 
         - 0
-        version: "0"
+        - 6
+        version: "0.6"
   type: :development
+  name: yard
+  prerelease: false
   version_requirements: *id005
-description: Organise genome sequence data into scaffolds using YAML configuration files.
+- !ruby/object:Gem::Dependency 
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 0
+        - 9
+        version: "0.9"
+  type: :development
+  name: cucumber
+  prerelease: false
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 1
+        - 5
+        version: "1.5"
+  type: :development
+  name: jeweler
+  prerelease: false
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 1
+        - 2
+        version: "1.2"
+  type: :development
+  name: redgreen
+  prerelease: false
+  version_requirements: *id008
+description: Organise sequence contigs into genome scaffolds using simple human-readable YAML files.
 email: mail@michaelbarton.me.uk
 executables: []
 
@@ -101,29 +149,37 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - .document
-- .gitignore
+- Gemfile
 - LICENSE
 - README.rdoc
 - Rakefile
 - VERSION
+- cucumber.yml
+- features/insert.feature
+- features/sequence.feature
+- features/step_definitions/scaffolder_steps.rb
+- features/support/env.rb
 - lib/scaffolder.rb
-- lib/scaffolder/insert.rb
+- lib/scaffolder/errors.rb
 - lib/scaffolder/region.rb
-- lib/scaffolder/sequence.rb
+- lib/scaffolder/region/insert.rb
+- lib/scaffolder/region/sequence.rb
+- lib/scaffolder/region/unresolved.rb
 - scaffolder.gemspec
-- test/data/sequences.fna
 - test/helper.rb
 - test/test_insert.rb
 - test/test_region.rb
 - test/test_scaffolder.rb
 - test/test_sequence.rb
+- test/test_unresolved.rb
+- yard/attribute_handler.rb
 has_rdoc: true
-homepage: http://github.com/michaelbarton/scaffolder
-licenses: []
-
+homepage: http://www.michaelbarton.me.uk/scaffolder/
+licenses: 
+- MIT
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -150,10 +206,11 @@ rubyforge_project:
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Scaffolder for genome sequence data
+summary: Genome scaffolding for human beings.
 test_files: 
 - test/helper.rb
 - test/test_insert.rb
 - test/test_region.rb
 - test/test_scaffolder.rb
 - test/test_sequence.rb
+- test/test_unresolved.rb

data/.gitignore

@@ -1,22 +0,0 @@
-## MAC OS
-.DS_Store
-
-## TEXTMATE
-*.tmproj
-tmtags
-
-## EMACS
-*~
-\#*
-.\#*
-
-## VIM
-*.swp
-
-## PROJECT::GENERAL
-coverage
-doc
-.yardoc
-pkg
-
-## PROJECT::SPECIFIC