bioinform 0.1.3 → 0.1.4

data/lib/bioinform/data_models/parser.rb

@@ -1,38 +0,0 @@
-require 'bioinform/support'
-require 'bioinform/data_models/pm'
-
-module Bioinform
-  class Parser
-    attr_reader :input
-    
-    @subclasses ||= []
-    class << self
-      def subclasses
-        @subclasses
-      end  
-      def inherited(subclass)
-        Parser.subclasses << subclass
-      end
-    end
-    
-    def initialize(input)
-      @input = input
-    end
-    
-    def parse_core
-      raise NotImplemented
-    end
-    
-      
-    def parse
-      parse_core
-    end
-    
-    def can_parse?
-      parse_core
-      true
-    rescue
-      false
-    end
-  end
-end

data/lib/bioinform/data_models/parsers/array_parser.rb

@@ -1,17 +0,0 @@
-require 'bioinform/support'
-require 'bioinform/data_models/parser'
-
-module Bioinform
-  class ArrayParser < Parser
-    def parse_core
-      raise ArgumentError  unless input.is_a?(Array) && input.all?(&:is_a?.(Array)) && input.same_by?(&:length) && (input.size == 4 || input.sample.size == 4)
-      if input.all?{|line| line.size == 4}
-        {matrix: input}
-      elsif input.size == 4
-        {matrix: input.transpose}
-      else
-        raise ArgumentError
-      end
-    end
-  end
-end

data/lib/bioinform/data_models/parsers/hash_parser.rb

@@ -1,19 +0,0 @@
-require 'bioinform/support'
-require 'bioinform/data_models/parser'
-
-module Bioinform
-  class HashParser < Parser
-    def parse_core
-      case input
-      when Hash
-        raise ArgumentError  unless input.with_indifferent_access.has_all_keys?(:A, :C, :G, :T) && input.with_indifferent_access.values_at(:A,:C,:G,:T).same_by?(&:length)
-        { matrix: input.with_indifferent_access.values_at(:A,:C,:G,:T).transpose }
-      when Array
-        raise ArgumentError  unless input.all?(&:is_a?.(Hash)) && input.all?{|position| position.size == 4}
-        { matrix: input.map(&:with_indifferent_access).map(&:values_at.(:A,:C,:G,:T)) }
-      else
-        raise ArgumentError
-      end
-    end
-  end
-end

data/lib/bioinform/data_models/parsers.rb

@@ -1,6 +0,0 @@
-# Parsers should be included after PM class defined - in order it could catch definitions of new classes
-
-require 'bioinform/data_models/parsers/array_parser'
-require 'bioinform/data_models/parsers/hash_parser'
-require 'bioinform/data_models/parsers/string_parser'
-require 'bioinform/data_models/parsers/string_fantom_parser'

data/spec/data_models/parser_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-require 'bioinform/data_models/parser'
-
-module Bioinform
-  describe Parser do
-    include Parser::Helpers
-    
-    before :each do
-      parser_stub :ParserBad, false, { matrix: [[0,0,0,0],[1,1,1,1]], name: 'Bad' }
-      parser_stub :ParserGood, true, { matrix: [[1,1,1,1],[1,1,1,1]], name: 'Good' }
-    end
-    after :each do  
-      parser_subclasses_cleanup 
-    end
-
-    context 'when subklass created' do
-      it 'Parser.subclasses should contain all subclasses' do
-        Parser.subclasses.should include ParserBad
-        Parser.subclasses.should include ParserGood
-      end
-    end
-    
-    describe '#initialize' do
-      it 'should save argument `input`'do
-        parser = ParserGood.new('my stub input')
-        parser.input.should == 'my stub input'
-      end
-    end
-    
-    describe '#parse' do
-      it 'should raise an error unless reimplemented' do
-        parser = Parser.new('my stub input')
-        expect{ parser.parse }.to raise_error
-      end
-      
-      context 'in a subclass' do
-        it '!!! USELESS TEST - see TODO and make LINT for subclasses!!! should return hash with key `matrix`' do
-          parser = ParserGood.new('my stub input')
-          parse_result = parser.parse
-          parse_result.should be_kind_of Hash
-          parse_result.should have_key :matrix
-        end
-      end
-    end
-  end
-end

data/spec/data_models/parsers/array_parser_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-require 'bioinform/data_models/parsers/array_parser'
-
-module Bioinform
-  describe ArrayParser do
-    before :each do
-      @matrix = [[1,4,7,10], [2,5,8,11], [3,6,9,12]]
-      
-      @valid_input = [[1,4,7,10], [2,5,8,11], [3,6,9,12]]
-      @valid_input_transposed = [[1,2,3], [4,5,6], [7,8,9], [10,11,12]]
-      
-      @invalid_array_of_hashes = [{A: 1, C: 4, G: 7, T: 10}, {A: 2, C: 5, G: 8, T: 11}, {A: 3, C: 6, G: 9, T: 12}]
-      @invalid_input_hash = {A: [1,2,3], C: [4,5,6], G: [7,8,9], T: [10,11,12]}
-      
-      @invalid_input_array_different_size = [[1,4,7,10], [2,5,8,11], [3,6]]
-      @invalid_input_array_transposed_different_size = [[1,2,3],[4,5,6],[7,8,9],[10]]
-      
-      @invalid_not_hash_string = "1 2 3\n4 5 6\n7 8 9\n10 11 12"
-      @invalid_not_hash_string_transposed = "1 2 3 4\n5 6 7 8\n9 10 11 12"
-    end
-    
-    describe '#can_parse?' do
-      it 'should be true for a valid array' do
-        ArrayParser.new(@valid_input).can_parse?.should be_true
-        ArrayParser.new(@valid_input_transposed).can_parse?.should be_true
-      end
-      it 'should be false for invalid input' do
-        ArrayParser.new(@invalid_array_of_hashes).can_parse?.should be_false
-        ArrayParser.new(@invalid_input_hash).can_parse?.should be_false
-        
-        ArrayParser.new(@invalid_input_array_different_size).can_parse?.should be_false
-        ArrayParser.new(@invalid_input_array_transposed_different_size).can_parse?.should be_false
-        
-        ArrayParser.new(@invalid_not_hash_string).can_parse?.should be_false
-        ArrayParser.new(@invalid_not_hash_string_transposed).can_parse?.should be_false
-      end
-    end
-    describe '#parse' do
-      it 'should raise an ArgumentError for invalid input' do
-        expect{ ArrayParser.new(@invalid_array_of_hashes).parse }.to raise_error ArgumentError
-        expect{ ArrayParser.new(@invalid_input_hash).parse }.to raise_error ArgumentError
-        expect{ ArrayParser.new(@invalid_input_array_different_size).parse }.to raise_error ArgumentError
-        expect{ ArrayParser.new(@invalid_input_array_transposed_different_size).parse }.to raise_error ArgumentError
-        expect{ ArrayParser.new(@invalid_not_hash_string).parse }.to raise_error ArgumentError
-        expect{ ArrayParser.new(@invalid_not_hash_string_transposed).parse }.to raise_error ArgumentError
-      end
-      it 'should return hash with `matrix` key for valid input' do
-        ArrayParser.new(@valid_input).parse.should == {matrix: @matrix}
-        ArrayParser.new(@valid_input_transposed).parse.should == {matrix: @matrix}
-      end
-    end
-  end
-end

data/spec/data_models/parsers/hash_parser_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-require 'bioinform/data_models/parsers/hash_parser'
-
-module Bioinform
-  describe HashParser do
-    before :each do
-      @matrix = [[1,4,7,10], [2,5,8,11], [3,6,9,12]]
-      
-      @valid_input_symbolic_keys = {A: [1,2,3], C: [4,5,6], G: [7,8,9], T: [10,11,12]}
-      @valid_input_string_keys = {'A' => [1,2,3], 'C' => [4,5,6], 'G' => [7,8,9], 'T' => [10,11,12]}
-      @valid_array_of_hashes = [{A: 1, C: 4, G: 7, T: 10}, {A: 2, C: 5, G: 8, T: 11}, {A: 3, C: 6, G: 9, T: 12}]
-      
-      @invalid_array_of_hashes_missing_keys = [{A: 1, C: 4, G: 7, T: 10}, {C: 5, T: 11}, {A: 3, C: 6, G: 9, T: 12}]
-      
-      @invalid_input_different_length = {A: [1,2,3], C: [4,5,6], G: [7,8,9], T: [10]}
-      @invalid_input_not_all_keys = {A: [1,2,3], C: [4,5,6], G: [7,8,9]}
-      
-      @invalid_not_hash_array = [[1,2,3], [4,5,6], [7,8,9], [10,11,12]]
-      @invalid_not_hash_array_transposed = [[1,4,7,10], [2,5,8,11], [3,6,9,12]]
-      
-      @invalid_not_hash_string = "1 2 3\n4 5 6\n7 8 9\n10 11 12"
-      @invalid_not_hash_string_transposed = "1 2 3 4\n5 6 7 8\n9 10 11 12"
-    end
-    describe '#can_parse?' do
-      it 'should be true for a valid hash or array of hashes' do
-        HashParser.new(@valid_input_symbolic_keys).can_parse?.should be_true
-        HashParser.new(@valid_input_string_keys).can_parse?.should be_true
-        HashParser.new(@valid_array_of_hashes).can_parse?.should be_true
-      end
-      it 'should be false for invalid input' do
-        HashParser.new(@invalid_array_of_hashes_missing_keys).can_parse?.should be_false
-        HashParser.new(@invalid_input_different_length).can_parse?.should be_false
-        HashParser.new(@invalid_input_not_all_keys).can_parse?.should be_false
-        
-        HashParser.new(@invalid_not_hash_array).can_parse?.should be_false
-        HashParser.new(@invalid_not_hash_array_transposed).can_parse?.should be_false
-        
-        HashParser.new(@invalid_not_hash_string).can_parse?.should be_false
-        HashParser.new(@invalid_not_hash_string_transposed).can_parse?.should be_false
-      end
-    end
-    describe '#parse' do
-      it 'should raise an ArgumentError for invalid input' do
-        expect{ HashParser.new(@invalid_input_different_length).parse }.to raise_error ArgumentError
-        expect{ HashParser.new(@invalid_input_not_all_keys).parse }.to raise_error ArgumentError
-        
-        expect{ HashParser.new(@invalid_not_hash_array).parse }.to raise_error ArgumentError
-        expect{ HashParser.new(@invalid_not_hash_array_transposed).parse }.to raise_error ArgumentError
-        
-        expect{ HashParser.new(@invalid_not_hash_string).parse }.to raise_error ArgumentError
-        expect{ HashParser.new(@invalid_not_hash_string_transposed).parse }.to raise_error ArgumentError
-      end
-      it 'should return hash with `matrix` key for valid input' do
-        HashParser.new(@valid_input_symbolic_keys).parse.should == {matrix: @matrix}
-        HashParser.new(@valid_input_string_keys).parse.should == {matrix: @matrix}
-        HashParser.new(@valid_array_of_hashes).parse.should == {matrix: @matrix}
-      end
-    end
-  end
-end

data/spec/data_models/parsers/string_fantom_parser_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-require 'bioinform/data_models/parsers/string_fantom_parser'
-
-module Bioinform
-  describe StringFantomParser do
-    before :each do
-      @matrix = [[0.0, 1878368.0, 0.0, 0.0], 
-                 [0.0, 0.0, 0.0, 1878368.0], 
-                 [469592.0, 469592.0, 469592.0, 469592.0], 
-                 [0.0, 1878368.0, 0.0, 0.0], 
-                 [1878368.0, 0.0, 0.0, 0.0], 
-                 [0.0, 0.0, 1878368.0, 0.0]]
-      
-      @good_input = <<-EOS
-        NA  motif_CTNCAG					
-        P0	A	C	G	T	
-        P1	0	1878368	0	0	
-        P2	0	0	0	1878368	
-        P3	469592	469592	469592	469592	
-        P4	0	1878368	0	0	
-        P5	1878368	0	0	0	
-        P6	0	0	1878368	0	
-      EOS
-    end
-    
-    describe '#can_parse?' do
-      it 'should parse particular kind of string' do
-        StringFantomParser.new(@good_input).can_parse?.should be_true
-      end
-    end
-    
-    describe '#parse' do
-      it 'should parse particular kind of string' do
-        StringFantomParser.new(@good_input).parse.should == { matrix: @matrix, name: 'motif_CTNCAG'}
-      end
-    end
-  end
-end

data/spec/data_models/parsers/string_parser_spec.rb

@@ -1,156 +0,0 @@
-require 'spec_helper'
-require 'bioinform/data_models/parsers/string_parser'
-
-module Bioinform
-  describe StringParser do
-    before :each do
-      @matrix = [[1.23, 4.56, 7.8, 9.0],[9.0, -8.7, 6.54, -3210.0]]
-      
-      @input_with_name = <<-EOS
-        Testmatrix
-        1.23 4.56 7.8 9.0
-        9 -8.7 6.54 -3210
-      EOS
-      
-      @input_with_name_with_introduction_sign = <<-EOS
-        > Testmatrix
-        1.23 4.56 7.8 9.0
-        9 -8.7 6.54 -3210
-      EOS
-      
-      @input_with_name_with_special_characters = <<-EOS
-        Testmatrix_first:subname+sub-subname
-        1.23 4.56 7.8 9.0
-        9 -8.7 6.54 -3210
-      EOS
-      
-      @input_with_tabs_and_multiple_spaces = <<-EOS
-        > \tTestmatrix
-        1.23  \t 4.56 7.8\t\t 9.0
-        9    -8.7 6.54 -3210
-      EOS
-      
-      @input_with_windows_crlf = <<-EOS
-        > Testmatrix\r
-        1.23 4.56 7.8 9.0
-        9 -8.7 6.54 -3210\r
-      EOS
-      
-      @input_with_leading_and_finishing_spaces_and_newlines = <<-EOS
-        \n\n
-        \t1.23 4.56 7.8 9.0
-        9 -8.7 6.54 -3210
-          \t\r\n\t\n
-      EOS
-      
-      @input_without_name = <<-EOS
-        1.23 4.56 7.8 9.0
-        9 -8.7 6.54 -3210
-      EOS
-      
-      @input_with_exponent = <<-EOS
-        1.23 4.56 7.8 9.0
-        9 -8.7 6.54 -3.210e3
-      EOS
-      
-      @input_with_plus_exponent = <<-EOS
-        1.23 4.56 7.8 9.0
-        9 -8.7 6.54 -3.210e+3
-      EOS
-      
-      @input_with_minus_exponent = <<-EOS
-        1.23 4.56 7.8 9.0
-        9 -87e-1 6.54 -3210
-      EOS
-      
-      @input_with_upcase_exponent = <<-EOS
-        1.23 4.56 7.8 9.0
-        9 -8.7 6.54 -3.210E3
-      EOS
-      
-      @input_with_manydigit_exponent = <<-EOS
-        1.23 4.56 7.8 9.0
-        9 -8.7 6.54 -0.0000003210e10
-      EOS
-      
-      @input_transposed = <<-EOS
-        1.23 9  
-        4.56 -8.7
-        7.8 6.54 
-        9.0 -3210
-      EOS
-      
-      
-      @bad_input_not_numeric = <<-EOS
-        1.23 4.56 aaa 9.0
-        9 -8.7 6.54 -3210
-      EOS
-      
-      @bad_input_different_row_size = <<-EOS
-        1.23 4.56 7.8 9
-        9 -8.7 6.54
-      EOS
-      
-      @bad_input_not_4_rows_and_cols = <<-EOS
-        1.23  4.56  7.8 
-        9    -8.7   6.54
-        10    2     10
-        4     5     6
-        1     1     1
-      EOS
-      
-      @bad_input_with_empty_exponent = <<-EOS
-        1.23 4.56 7.8 9.0
-        9e -8.7 6.54 3210
-      EOS
-    end
-    
-    describe '#can_parse?' do
-      it 'should return true for valid input string' do
-        StringParser.new(@input_with_name).can_parse?.should be_true
-        StringParser.new(@input_with_name_with_introduction_sign).can_parse?.should be_true
-        StringParser.new(@input_with_name_with_special_characters).can_parse?.should be_true
-        StringParser.new(@input_with_tabs_and_multiple_spaces).can_parse?.should be_true
-        StringParser.new(@input_with_windows_crlf).can_parse?.should be_true
-        StringParser.new(@input_with_leading_and_finishing_spaces_and_newlines).can_parse?.should be_true
-        StringParser.new(@input_without_name).can_parse?.should be_true
-        StringParser.new(@input_transposed).can_parse?.should be_true
-        StringParser.new(@input_with_exponent).can_parse?.should be_true
-        StringParser.new(@input_with_plus_exponent).can_parse?.should be_true
-        StringParser.new(@input_with_minus_exponent).can_parse?.should be_true
-        StringParser.new(@input_with_upcase_exponent).can_parse?.should be_true
-        StringParser.new(@input_with_manydigit_exponent).can_parse?.should be_true
-        
-      end
-      it 'should return false for invalid input string' do
-        StringParser.new(@bad_input_not_numeric).can_parse?.should be_false
-        StringParser.new(@bad_input_different_row_size).can_parse?.should be_false
-        StringParser.new(@bad_input_not_4_rows_and_cols).can_parse?.should be_false
-        StringParser.new(@bad_input_with_empty_exponent).can_parse?.should be_false
-      end
-    end
-    describe '#parse' do
-      it 'should return a hash with matrix and possibly name keys for valid input string' do
-        StringParser.new(@input_with_name).parse.should == {matrix: @matrix, name: 'Testmatrix'}
-        StringParser.new(@input_with_name_with_introduction_sign).parse.should == {matrix: @matrix, name: 'Testmatrix'}
-        StringParser.new(@input_with_name_with_special_characters).parse.should == {matrix: @matrix, name: 'Testmatrix_first:subname+sub-subname'}
-        StringParser.new(@input_with_tabs_and_multiple_spaces).parse.should == {matrix: @matrix, name: 'Testmatrix'}
-        StringParser.new(@input_with_windows_crlf).parse.should == {matrix: @matrix, name: 'Testmatrix'}
-        StringParser.new(@input_with_leading_and_finishing_spaces_and_newlines).parse.should == {matrix: @matrix}
-        StringParser.new(@input_without_name).parse.should == {matrix: @matrix}
-        StringParser.new(@input_transposed).parse.should == {matrix: @matrix}
-        StringParser.new(@input_with_exponent).parse.should == {matrix: @matrix}
-        StringParser.new(@input_with_plus_exponent).parse.should == {matrix: @matrix}
-        StringParser.new(@input_with_minus_exponent).parse.should == {matrix: @matrix}
-        StringParser.new(@input_with_upcase_exponent).parse.should == {matrix: @matrix}
-        StringParser.new(@input_with_manydigit_exponent).parse.should == {matrix: @matrix}
-      end
-      it 'should raise an error for invalid input string' do
-        expect{ StringParser.new(@bad_input_not_numeric).parse }.to raise_error ArgumentError
-        expect{ StringParser.new(@bad_input_different_row_size).parse }.to raise_error ArgumentError
-        expect{ StringParser.new(@bad_input_not_4_rows_and_cols).parse }.to raise_error ArgumentError
-        expect{ StringParser.new(@bad_input_with_empty_exponent).parse }.to raise_error ArgumentError
-      end
-    end
-  end
-end