bioinform 0.1.8 → 0.1.9

data/lib/bioinform/data_models/motif.rb

@@ -0,0 +1,56 @@
+require 'ostruct'
+require 'active_support/core_ext/object/try'
+require_relative '../support/parameters'
+module Bioinform
+  class Motif
+    include Parameters
+    make_parameters :pcm, :pwm, :ppm, :name, :original_data_model
+
+    # 0)Motif.new()
+    # 1)Motif.new(pcm: ..., pwm: ..., name: ...,threshold: ...)
+    # 2)Motif.new(my_pcm)
+    # 3)Motif.new(pm: my_pcm, threshold: ...)
+    # 2) and 3) cases will automatically choose data model
+    #### What if pm already is a Motif
+    def initialize(parameters = {})
+      case parameters
+      when PM
+        pm = parameters
+        motif_type = pm.class.name.downcase.sub(/^.+::/,'').to_sym
+        self.original_data_model = motif_type
+        set_parameters(motif_type => pm)
+      when Hash
+        if parameters.has_key?(:pm) && parameters[:pm].is_a?(PM)
+          pm = parameters.delete(:pm)
+          motif_type = pm.class.name.downcase.sub(/^.+::/,'').to_sym
+          self.original_data_model = motif_type
+          set_parameters(motif_type => pm)
+        end
+        set_parameters(parameters)
+      else
+        raise ArgumentError, "Motif::new doesn't accept argument #{parameters} of class #{parameters.class}"
+      end
+    end
+
+    def pm; ((original_data_model || :pm) == :pm) ? parameters.pm : send(original_data_model); end
+    #def pcm; parameters.pcm; end
+    def pwm; parameters.pwm || pcm.try(:to_pwm); end
+    def ppm; parameters.ppm || pcm.try(:to_ppm); end
+    #def pcm=(pcm); parameters.pcm = pcm; end
+    #def pwm=(pwm); parameters.pwm = pwm; end
+    #def ppm=(ppm); parameters.ppm = ppm; end
+    def name; parameters.name || pm.name; end
+
+    def method_missing(meth, *args)
+      parameters.__send__(meth, *args)
+    end
+
+    def ==(other)
+      parameters == other.parameters
+    end
+    
+    def to_s
+      parameters.to_s
+    end
+  end
+end

data/lib/bioinform/data_models/pcm.rb

@@ -1,5 +1,7 @@
 require_relative '../support'
 require_relative '../data_models'
+require_relative '../conversion_algorithms/pcm2ppm_converter'
+require_relative '../conversion_algorithms/pcm2pwm_converter'
 
 module Bioinform
   class PCM < PM
@@ -12,17 +14,11 @@ module Bioinform
     end
 
     def to_pwm(pseudocount = Math.log(count))
-      mat = each_position.map do |pos|
-        pos.each_index.map do |ind|
-          Math.log((pos[ind] + probability[ind] * pseudocount) / (probability[ind]*(count + pseudocount)) )
-        end
-      end
-      PWM.new(matrix: mat, name: name, tags: tags, background: background)
+      ConversionAlgorithms::PCM2PWMConverter.convert(self, pseudocount: pseudocount)
     end
 
     def to_ppm
-      mat = each_position.map{|pos| pos.map{|el| el.to_f / count }}
-      PPM.new(matrix: mat, name: name, tags: tags, background: background)
+      ConversionAlgorithms::PCM2PPMConverter.convert(self)
     end
   end
 end

data/lib/bioinform/data_models/pm.rb

@@ -1,6 +1,7 @@
 require 'ostruct'
 require_relative '../support'
 require_relative '../parsers'
+require_relative '../formatters'
 
 module Bioinform
   IndexByLetter = {'A' => 0, 'C' => 1, 'G' => 2, 'T' => 3, A: 0, C: 1, G: 2, T: 3}
@@ -10,22 +11,22 @@ module Bioinform
     attr_accessor :matrix, :parameters
 
     include Parameters
-    make_parameters :tags, :name, :background
+    make_parameters  :name, :background # , :tags
 
-    def mark(tag)
-      tags << tag
-    end
+#    def mark(tag)
+#      tags << tag
+#    end
 
-    def tagged?(tag)
-      tags.any?{|t| (t.eql? tag) || (t.respond_to?(:name) && t.name && (t.name == tag)) }
-    end
+#    def tagged?(tag)
+#      tags.any?{|t| (t.eql? tag) || (t.respond_to?(:name) && t.name && (t.name == tag)) }
+#    end
 
     def self.choose_parser(input)
-      [TrivialParser, YAMLParser, Parser, StringParser, StringFantomParser, TrivialCollectionParser, YAMLCollectionParser].find do |parser|
+      [TrivialParser, YAMLParser, Parser, StringParser, StringFantomParser, JasparParser, TrivialCollectionParser, YAMLCollectionParser].find do |parser|
         self.new(input, parser) rescue nil
       end
     end
-    
+
     def self.split_on_motifs(input)
       parser = choose_parser(input)
       raise ParsingError, "No parser can parse given input"  unless parser
@@ -39,7 +40,7 @@ module Bioinform
       result = parser.new(input).parse
       @matrix = result.matrix
       self.name = result.name
-      self.tags = result.tags || []
+#      self.tags = result.tags || []
       self.background = result.background || [1, 1, 1, 1]
       raise 'matrix not valid'  unless valid?
     end
@@ -77,21 +78,8 @@ module Bioinform
     end
     alias_method :size, :length
 
-    def to_s(options = {})
-      default_options = {with_name: true, letters_as_rows: false}
-      options = default_options.merge(options)
-      if options[:letters_as_rows]
-        hsh = to_hash
-        matrix_str = [:A,:C,:G,:T].collect{|letter| "#{letter}|" + hsh[letter].join("\t")}.join("\n")
-      else
-        matrix_str = each_position.map{|pos| pos.join("\t")}.join("\n")
-      end
-
-      if options[:with_name] && name
-        name + "\n" + matrix_str
-      else
-        matrix_str
-      end
+    def to_s(options = {}, formatter = RawFormatter)
+      formatter.new(self, options).to_s
     end
 
     def pretty_string(options = {})
@@ -152,22 +140,6 @@ module Bioinform
       background.map{|element| element.to_f / sum}
     end
 
-    def best_score
-      @matrix.inject(0.0){|sum, col| sum + col.max}
-    end
-    def worst_score
-      @matrix.inject(0.0){|sum, col| sum + col.min}
-    end
-
-    # best score of suffix s[i..l]
-    def best_suffix(i)
-      @matrix[i...length].map(&:max).inject(0.0, &:+)
-    end
-
-    def worst_suffix(i)
-      @matrix[i...length].map(&:min).inject(0.0, &:+)
-    end
-
     def reverse_complement
       dup.reverse_complement!
     end
@@ -184,15 +156,14 @@ module Bioinform
       deep_dup
     end
 
-    def to_pcm
-      PCM.new(matrix: matrix, name: name, tags: tags, background: background)
+    def as_pcm
+      PCM.new(get_parameters.merge(matrix: matrix))
     end
-    def to_ppm
-      PPM.new(matrix: matrix, name: name, tags: tags, background: background)
+    def as_ppm
+      PPM.new(get_parameters.merge(matrix: matrix))
     end
-    def to_pwm
-      PWM.new(matrix: matrix, name: name, tags: tags, background: background)
+    def as_pwm
+      PWM.new(get_parameters.merge(matrix: matrix))
     end
-
   end
 end

data/lib/bioinform/data_models/pwm.rb

@@ -36,5 +36,21 @@ module Bioinform
     def to_pwm
       self
     end
+
+    def best_score
+      @matrix.inject(0.0){|sum, col| sum + col.max}
+    end
+    def worst_score
+      @matrix.inject(0.0){|sum, col| sum + col.min}
+    end
+
+    # best score of suffix s[i..l]
+    def best_suffix(i)
+      @matrix[i...length].map(&:max).inject(0.0, &:+)
+    end
+
+    def worst_suffix(i)
+      @matrix[i...length].map(&:min).inject(0.0, &:+)
+    end
   end
 end

data/lib/bioinform/formatters.rb

@@ -0,0 +1,2 @@
+require_relative 'formatters/raw_formatter'
+require_relative 'formatters/transfac_formatter'

data/lib/bioinform/formatters/raw_formatter.rb

@@ -0,0 +1,41 @@
+class RawFormatter
+  attr_accessor :motif, :options
+  
+  def initialize(motif, options = {})
+    @motif = motif
+    
+    default_options = {with_name: true, letters_as_rows: false}
+    @options = default_options.merge(options)
+  end
+  
+  def name
+    motif.name
+  end
+  
+  def header
+    if options[:with_name] && name
+      name + "\n"
+    else
+      ''
+    end
+  end
+  
+  def matrix_string
+    if options[:letters_as_rows]
+      hsh = motif.to_hash
+      [:A,:C,:G,:T].collect{|letter| "#{letter}|" + hsh[letter].join("\t")}.join("\n")
+    else
+      motif.each_position.map{|pos| pos.join("\t")}.join("\n")
+    end
+  end
+  
+  def footer
+    # "\n"
+    ''
+  end
+  
+  
+  def to_s
+    header + matrix_string + footer
+  end
+end

data/lib/bioinform/formatters/transfac_formatter.rb

@@ -0,0 +1,39 @@
+class TransfacFormatter
+  attr_accessor :motif, :options
+  
+  def initialize(motif, options = {})
+    @motif = motif
+    
+    default_options = {with_name: true, letters_as_rows: false}
+    @options = default_options.merge(options)
+  end
+  
+  def name
+    motif.name
+  end
+  
+  def header
+    if options[:with_name] && name
+      "ID #{name}\nBF StubSpeciesName\nP0\tA\tC\tG\tT\n"
+    else
+      raise 'Transfac should have the name field'
+    end
+  end
+  
+  def matrix_string
+    motif.each_position.map.with_index{|pos,ind| 
+      line_number = ind.to_s
+      line_number = (line_number.size == 1) ? "0#{line_number}" : line_number
+      line_number + ' ' + pos.join("\t")
+    }.join("\n")
+  end
+  
+  def footer
+    #"XX\n//\n"
+    "\nXX\n//"
+  end
+  
+  def to_s
+    header + matrix_string + footer
+  end
+end

data/lib/bioinform/parsers.rb

@@ -3,4 +3,5 @@ require_relative 'parsers/trivial_parser'
 require_relative 'parsers/yaml_parser'
 require_relative 'parsers/string_parser'
 require_relative 'parsers/string_fantom_parser'
-require_relative 'parsers/splittable_parser'
+require_relative 'parsers/splittable_parser'
+require_relative 'parsers/jaspar_parser'

data/lib/bioinform/parsers/jaspar_parser.rb

@@ -0,0 +1,35 @@
+require_relative '../support'
+require_relative '../parsers/string_parser'
+
+module Bioinform
+  class JasparParser < StringParser
+    def header_pat
+      /(?<name>)/
+    end
+
+    def row_pat
+      /[ACGT]\s*\[\s*(?<row>(#{number_pat}\s+)*#{number_pat})\s*\]\n?/
+    end
+
+    def scan_splitter
+      scanner.scan(/(\/\/\n)+/)
+    end
+
+    def parse_matrix
+      matrix = []
+      while row_string = scan_row
+        matrix << split_row(row_string)
+      end
+      matrix.transpose
+    end
+
+    def parse!
+      scan_any_spaces
+      scan_splitter
+      name = parse_name
+      matrix = parse_matrix
+      Parser.parse!(matrix).tap{|result| result.name = name}
+    end
+
+  end
+end

data/lib/bioinform/parsers/string_parser.rb

@@ -8,7 +8,7 @@ module Bioinform
     attr_reader :scanner, :row_acgt_markers
 
     def initialize(input)
-      raise ArgumentError  unless input.is_a?(String)
+      raise ArgumentError, 'StringParser should be initialized with a String'  unless input.is_a?(String)
       super
       @scanner = StringScanner.new(input.multiline_squish)
     end

data/lib/bioinform/parsers/trivial_parser.rb

@@ -15,6 +15,7 @@ module Bioinform
     def parse!
       case input
       when PM then input
+      when Motif then input.pm
       when OpenStruct then input
       when Hash then OpenStruct.new(input)
       end
@@ -27,7 +28,7 @@ module Bioinform
       @input = input
     end
     def parse!
-      input.collection.shift.first
+      input.container.shift.pm
     end
   end
 end

data/lib/bioinform/parsers/yaml_parser.rb

@@ -27,7 +27,7 @@ module Bioinform
       @collection ||= YAML.load(input)
     end
     def parse!
-      collection.collection.shift.first
+      collection.container.shift.pm
     rescue Psych::SyntaxError
       raise 'parsing error'
     end

data/lib/bioinform/support.rb

@@ -14,4 +14,5 @@ require_relative 'support/array_zip'
 require_relative 'support/array_product'
 
 require_relative 'support/advanced_scan'
-require_relative 'support/parameters'
+require_relative 'support/parameters'
+require_relative 'support/strip_doc'

data/lib/bioinform/support/parameters.rb

@@ -1,19 +1,28 @@
-require 'ostruct'
-module Parameters
-  def self.included(base)
-    base.extend(ClassMethods)
-  end
-  module ClassMethods
-    def make_parameters(*params)
-      params.each do |param|
-        define_method(param){ parameters.send(param) }
-        define_method("#{param}="){|new_value| parameters.send("#{param}=", new_value) }
-      end
-    end
-  end
-  def parameters; @parameters ||= OpenStruct.new; end
-  def set_parameters(hsh)
-    hsh.each{|k,v| send("#{k}=", v) }
-    self
-  end
+require 'ostruct'
+module Bioinform
+  module Parameters
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    module ClassMethods
+      def make_parameters(*params)
+        params.each do |param|
+          define_method(param){ parameters.send(param) }
+          define_method("#{param}="){|new_value| parameters.send("#{param}=", new_value) }
+        end
+      end
+    end
+    def parameters; @parameters ||= OpenStruct.new; end
+    def set_parameters(hsh)
+      hsh.each{|k,v| send("#{k}=", v) }
+      self
+    end
+    # return hash of parameters
+    def get_parameters
+      @parameters.marshal_dump
+    end
+    def parameter_defined?(param_name)
+      get_parameters.has_key?(param_name)
+    end
+  end
 end