bioinform 0.0.1 → 0.1.0

data/lib/bioinform/support/callable_symbol.rb

@@ -1,11 +1,40 @@
 require 'bioinform/support/curry_except_self'
 
+# Useful extension for &:symbol - syntax to make it possible to pass arguments for method in block
+#   ['abc','','','def','ghi'].tap(&:delete.(''))             # ==> ['abc','def','ghi']
+#   [1,2,3].map(&:to_s.(2))                                  # ==> ['1','10','11']
+#   ['abc','cdef','xy','z','wwww'].select(&:size.() == 4)    # ==> ['cdef', 'wwww']
+#   ['abc','aaA','AaA','z'].count(&:upcase.().succ == 'AAB') # ==> 2
+#   [%w{1 2 3 4 5},%w{6 7 8 9}].map(&:join.().length)         # ==> [5,4]
 class Symbol
-  def call(*args)
-    obj=Object.new.instance_exec(self,args){|sym,params| @sym=sym; @args = params; self}
-    obj.define_singleton_method :to_proc do
-      @sym.to_proc.curry_except_self(*@args)
+  def call(*args, &block)
+    obj=BasicObject.new.instance_exec(self,args,block) do |meth,params,block| 
+      @postprocess_meth = [meth]
+      @postprocess_args = [params]
+      @postprocess_block = [block]
+      self
     end
+    
+    def obj.to_proc
+      # proc/lambda are methods that cannot be used in BasicObject. It's possible to use ->(slf){...} syntax since ruby-1.9.3 p194 but it's too modern and not widely spreaded yet
+      ::Proc.new do |slf| 
+        @postprocess_meth.zip(@postprocess_args,@postprocess_block).inject(slf) do |result,(call_meth,call_args,call_block)| 
+          result.send(call_meth, *call_args,&call_block) 
+        end
+      end
+    end
+    
+    def obj.method_missing(meth,*args,&block)
+      @postprocess_meth << meth
+      @postprocess_args << args
+      @postprocess_block << block
+      self
+    end
+    
+    def obj.==(other)
+      method_missing(:==, other)
+    end
+    
     obj
   end
 end

data/lib/bioinform/support/collect_hash.rb

@@ -0,0 +1,7 @@
+module Enumerable
+  # %w{A C G T}.collect_hash{|k| [k*2, k*3] }
+  # # ==> {"AA" => "AAA", "CC" => "CCC", "GG" => "GGG", "TT" => "TTT"}
+  def collect_hash(&block)
+    block_given?  ?  Hash[ collect(&block) ]  :  Hash[ collect{|k,v| [k,v]} ]    
+  end
+end

data/lib/bioinform/support/curry_except_self.rb

@@ -1,5 +1,5 @@
 class Proc
-  def curry_except_self(*args)
-    Proc.new{|slf| curry[slf,*args] }
+  def curry_except_self(*args, &block)
+    Proc.new{|slf| curry.call(slf, *args, &block) }
   end
 end

data/lib/bioinform/support/deep_dup.rb

@@ -0,0 +1,5 @@
+class Object
+  def deep_dup
+    Marshal.load(Marshal.dump(self))
+  end
+end

data/lib/bioinform/support/delete_many.rb

@@ -0,0 +1,14 @@
+class Array
+  def delete_at_many(*indices)
+    indices.uniq.sort.reverse.each{|ind| delete_at ind}
+  end
+  def delete_many(*elements)
+    elements.each{|el| delete el}
+  end
+end
+
+class Hash
+  def delete_many(*keys)
+    keys.each{|el| delete el}
+  end
+end

data/lib/bioinform/support/has_keys.rb

@@ -0,0 +1,14 @@
+class Hash
+  def has_all_keys?(*keys)
+    keys.all?{|key| has_key? key}
+  end
+  def has_any_key?(*keys)
+    keys.any?{|key| has_key? key}
+  end
+  def has_none_key?(*keys)
+    keys.none?{|key| has_key? key}
+  end
+  def has_one_key?(*keys)
+    keys.one?{|key| has_key? key}
+  end
+end

data/lib/bioinform/support/inverf.rb

@@ -0,0 +1,13 @@
+module Math
+  def self.inverf(x)
+    sign = x < 0 ? -1 : 1
+    x = x.abs
+    a = 8 / (3*Math::PI) * (Math::PI-3) / (4-Math::PI)
+    part0 = ( 2/(Math::PI*a) + (Math.log(1-x*x)) / 2 )**2
+    part = -2 / (Math::PI * a) - Math.log(1-x*x)/2 + Math.sqrt(-1/a * Math.log(1-x*x) + part0)
+    sign * Math.sqrt(part)
+  end
+  def inverf(x)
+    Math.inverf(x)
+  end
+end

data/lib/bioinform/support/partial_sums.rb

@@ -0,0 +1,6 @@
+class Array
+  def partial_sums(initial = 0.0)
+    sums = initial
+    map{|el| sums += el}
+  end
+end

data/lib/bioinform/support/{same.rb → same_by.rb}

@@ -1,5 +1,5 @@
 module Enumerable
-  def same?(&block)
+  def same_by?(&block)
     return true if empty?
     if block_given?
       first_result = yield(first)

data/lib/bioinform/support.rb

@@ -1,7 +1,15 @@
-require 'bioinform/support/curry_except_self'
+require 'active_support/core_ext/string/filters'
+require 'active_support/core_ext/hash/indifferent_access'
+
 require 'bioinform/support/callable_symbol'
-require 'bioinform/support/pmap'
-require 'bioinform/support/ptap'
-require 'bioinform/support/same'
+require 'bioinform/support/collect_hash'
+require 'bioinform/support/curry_except_self'
+require 'bioinform/support/delete_many'
+require 'bioinform/support/has_keys'
+require 'bioinform/support/multiline_squish'
+require 'bioinform/support/same_by'
 require 'bioinform/support/yaml_dump_file'
-require 'bioinform/support/multiline_squish'
+require 'bioinform/support/inverf'
+require 'bioinform/support/deep_dup'
+
+require 'bioinform/support/partial_sums'

data/lib/bioinform/version.rb

@@ -1,3 +1,3 @@
-module Bioinform
-  VERSION = "0.0.1"
-end
+module Bioinform
+  VERSION = "0.1.0"
+end

data/lib/bioinform.rb

@@ -1,7 +1,8 @@
-require 'bioinform/version'
-require 'bioinform/support'
-require 'bioinform/data_models'
-
-module Bioinform
-  # Your code goes here...
-end
+require 'bioinform/version'
+require 'bioinform/support'
+require 'bioinform/data_models'
+require 'bioinform/data_models/parsers'
+
+module Bioinform
+  # Your code goes here...
+end

data/spec/data_models/parser_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'bioinform/data_models/parser'
+
+module Bioinform
+  describe PM::Parser do
+    include PM::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 'PM::Parser.subclasses should contain all subclasses' do
+        PM::Parser.subclasses.should include ParserBad
+        PM::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 = PM::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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,112 @@
+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_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 -8.7 6.54 -3210
+      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
+    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
+      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
+      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}
+      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
+      end
+    end
+  end
+end