bioinform 0.1.17 → 0.2.0

data/lib/bioinform/errors.rb

@@ -0,0 +1,17 @@
+module Bioinform
+  class Error < ::StandardError
+  end
+
+  class ValidationError < Error
+    attr_reader :validation_errors
+
+    def initialize(msg, options = {})
+      super(msg)
+      @validation_errors = options.fetch(:validation_errors, [])
+    end
+
+    def to_s
+      "#{super} (#{@validation_errors.join('; ')})"
+    end
+  end
+end

data/lib/bioinform/formatters.rb

@@ -1,2 +1,4 @@
-require_relative 'formatters/raw_formatter'
-require_relative 'formatters/transfac_formatter'
+require_relative 'formatters/motif_formatter'
+require_relative 'formatters/pretty_matrix_formatter'
+require_relative 'formatters/transfac_formatter'
+require_relative 'formatters/consensus_formatter'

data/lib/bioinform/formatters/consensus_formatter.rb

@@ -0,0 +1,35 @@
+require_relative '../alphabet'
+
+module Bioinform
+  class ConsensusFormatter
+
+    # ConsensusFormatter.new{|pos, el, nucleotide_index| el == pos.max }
+    def initialize(&block)
+      raise Error, 'block is necessary to create an instance of ConsensusFormatter'  unless block_given?
+      @block = block
+    end
+
+    # Simplest consensus formatter which takes into account only maximal elements
+    def self.by_maximal_elements
+      self.new{|pos, el, nucleotide_index| el == pos.max }
+    end
+
+
+    def format_string(pm)
+      pm.each_position.map{|pos| iupac_letter_by_position(pos) }.join
+    end
+
+    def nucleotide_indices_by_position(pos)
+      pos.each_index.select{|nucleotide_index|
+        @block.call(pos, pos[nucleotide_index], nucleotide_index)
+      }
+    end
+
+    def iupac_letter_by_position(pos)
+      nucleotide_indices = nucleotide_indices_by_position(pos)
+      Bioinform::IUPAC::IUPACLettersByNucleotideIndices[nucleotide_indices]
+    end
+
+    private :nucleotide_indices_by_position, :iupac_letter_by_position
+  end
+end

data/lib/bioinform/formatters/motif_formatter.rb

@@ -0,0 +1,69 @@
+module Bioinform
+  class MotifFormatter
+    attr_reader :with_name, :nucleotides_in, :precision, :with_nucleotide_header, :with_position_header
+
+    def initialize(options = {})
+      @with_name = options.fetch(:with_name, :auto)
+      @nucleotides_in = options.fetch(:nucleotides_in, :columns).to_sym
+      @precision = options.fetch(:precision, false)
+      @with_nucleotide_header = options.fetch(:with_nucleotide_header, false)
+      @with_position_header = options.fetch(:with_position_header, false)
+      raise Error, "`with_name` can be either `true` or `false` or `:auto` but was `#{@with_name}`"  unless [true, false, :auto].include?(@with_name)
+      raise Error, "`nucleotides_in` can be either `:rows` or `:columns` but was `#{@nucleotides_in}`"  unless [:rows, :columns].include?(@nucleotides_in)
+    end
+
+    def format_name(motif)
+      case @with_name
+      when true
+        raise Error, "Motif doesn't respond to #name"  unless motif.respond_to?(:name)
+        ">#{motif.name}\n"
+      when false
+        ""
+      when :auto
+        (motif.respond_to?(:name) && motif.name && !motif.name.strip.empty?) ? ">#{motif.name}\n" : ""
+      end
+    end
+
+    def element_rounded(el)
+      precision ? sprintf("%.#{precision}g", el) : el.to_s
+    end
+
+    def position_index_formatted(pos)
+      sprintf('%02d', pos)
+    end
+
+    private :element_rounded, :position_index_formatted
+
+    def format_matrix(motif)
+      result = ""
+      result << "\t"  if with_nucleotide_header && with_position_header
+
+      case @nucleotides_in
+      when :columns
+        if with_nucleotide_header
+          result << motif.alphabet.each_letter.to_a.join("\t") << "\n"
+        end
+        motif.each_position.with_index do |pos, pos_index|
+          result << "\n"  if pos_index != 0
+          result << "#{position_index_formatted(pos_index + 1)}\t"  if with_position_header
+          result << pos.map{|el| element_rounded(el) }.join("\t")
+        end
+      when :rows
+        if with_position_header
+          result << (1..motif.length).map{|pos| position_index_formatted(pos) }.join("\t") << "\n"
+        end
+        motif.alphabet.each_letter.with_index do |letter, letter_index|
+          result << "\n"  if letter_index != 0
+          result << "#{letter}\t"  if with_nucleotide_header
+          result << motif.matrix.transpose[letter_index].map{|el| element_rounded(el) }.join("\t")
+        end
+      end
+      result
+    end
+
+    def format(motif)
+      format_name(motif) + format_matrix(motif)
+    end
+
+  end
+end

data/lib/bioinform/formatters/pretty_matrix_formatter.rb

@@ -0,0 +1,36 @@
+require_relative 'motif_formatter'
+
+module Bioinform
+  class PrettyMatrixFormatter
+    attr_reader :with_name, :letters_as_rows
+
+    def initialize(options = {})
+      @with_name = options.fetch(:with_name, true)
+      @letters_as_rows = options.fetch(:letters_as_rows, false)
+    end
+
+    def header
+      %w{A C G T}.map{|el| el.rjust(4).ljust(7)}.join + "\n"
+    end
+
+    def optional_name(motif)
+      (@with_name && motif.name) ? (motif.name + "\n") : ''
+    end
+
+    def matrix_string(motif)
+      matrix_rows = motif.each_position.map do |position|
+        position.map{|el| el.round(3).to_s.rjust(6)}.join(' ')
+      end
+
+      matrix_str = matrix_rows.join("\n")
+    end
+
+    def format(motif)
+      raise  Error, "PM doesn't respond to #name. Use formatter with option `with_name: false`"  if @with_name && !motif.respond_to?(:name)
+      return MotifFormatter.new(with_name: @with_name, nucleotides_in: (@letters_as_rows ? :rows : :columns)).format(motif)  if @letters_as_rows
+      optional_name(motif) + header + matrix_string(motif)
+    end
+
+    private :header, :optional_name, :matrix_string
+  end
+end

data/lib/bioinform/formatters/transfac_formatter.rb

@@ -1,39 +1,31 @@
-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'
+module Bioinform
+  class TransfacFormatter
+    attr_accessor :with_name
+
+    def initialize(options = {})
+      @with_name = options.fetch(:with_name, true)
     end
+
+    def header(motif)
+      if @with_name && motif.name
+        "ID #{motif.name}\nBF StubSpeciesName\nP0\tA\tC\tG\tT\n"
+      else
+        raise 'Transfac should have the name field'
+      end
+    end
+
+    def matrix_string(motif)
+      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 format(motif)
+      header(motif) + matrix_string(motif) + "\nXX\n//"
+    end
+
+    private :header, :matrix_string
   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
+end

data/lib/bioinform/parsers.rb

@@ -1,9 +1,2 @@
-require_relative 'parsers/parser'
-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/jaspar_parser'
-
 require_relative 'parsers/matrix_parser'
+require_relative 'parsers/motif_splitter'

data/lib/bioinform/parsers/matrix_parser.rb

@@ -1,32 +1,63 @@
-require 'ostruct'
+require_relative '../errors'
 
-module Bioinform  
+module Bioinform
   class MatrixParser
+    # fix_nucleotides_number -- raises if matrix has not enough nucleotide columns
+    attr_reader :has_name, :name_pattern, :has_header_row, :has_header_column, :nucleotides_in, :fix_nucleotides_number
     def initialize(options = {})
-      @has_name = options.fetch(:has_name, true)
-      @name_pattern = options.fetch(:name_pattern, /^>?\s*(?<name>[^\t\r\n]+).*$/)
+      @has_name = options.fetch(:has_name, :auto)
+      @name_pattern = options.fetch(:name_pattern, /^>?\s*(?<name>[^-+\d.\t\r\n][^\t\r\n]*).*$/)
       @has_header_row = options.fetch(:has_header_row, false)
       @has_header_column = options.fetch(:has_header_column, false)
-      @nucleotides_in = options.fetch(:nucleotides_in, :columns)
+      @nucleotides_in = options.fetch(:nucleotides_in, :auto)
+      @fix_nucleotides_number = options.fetch(:fix_nucleotides_number, 4)
 
-      raise ':nucleotides_in option should be either :rows or :columns' unless  [:rows, :columns].include?(@nucleotides_in)
+      raise Error, ':nucleotides_in option should be either :rows or :columns' unless  [:rows, :columns, :auto].include?(@nucleotides_in)
     end
 
+    def need_transpose?(matrix)
+      (matrix.size == @fix_nucleotides_number) && (matrix.first.size != 4)
+    end
+    private :need_transpose?
+
     def parse!(input)
-      lines = input.lines
-      if @has_name
+      lines = input.strip.lines.to_a
+      if @has_name == :auto
+        match = lines.first.match(@name_pattern)
+        if match
+          lines.shift
+          name = match[:name]
+        end
+      elsif @has_name == false
+        name = nil
+      else
         match = lines.shift.match(@name_pattern)
-        raise 'Name pattern doesn\'t match'  unless match
+        raise Error, "Name pattern doesn't match"  unless match
         name = match[:name]
       end
       lines.shift  if @has_header_row
-      matrix = lines.map(&:strip).reject(&:empty?).map{|line| line.split }
+      matrix = lines.map(&:rstrip).reject(&:empty?).map{|line| line.split }
       matrix = matrix.map{|row| row.drop(1) }  if @has_header_column
       matrix = matrix.map{|row| row.map{|el| Float(el) } }
 
-      matrix = matrix.transpose  if @nucleotides_in == :rows
-      # raise 'Matrix not valid' unless ! matrix.empty? && matrix.all?{|pos| pos.size == 4 }
-      OpenStruct.new(matrix: matrix, name: name)
+      case @nucleotides_in
+      when :columns
+        matrix = matrix
+      when :rows
+        matrix = matrix.transpose
+      when :auto
+        if @fix_nucleotides_number && need_transpose?(matrix)
+          matrix = matrix.transpose
+        end
+      end
+
+      if @fix_nucleotides_number
+        raise Error, 'Not enough nucleotides in a matrix'  unless matrix.all?{|pos| pos.size >= @fix_nucleotides_number}
+        matrix = matrix.map{|pos| pos.first(@fix_nucleotides_number) }
+      end
+      {matrix: matrix, name: name}
+    rescue => e
+      raise Error, e.message
     end
 
     def parse(input)
@@ -38,28 +69,5 @@ module Bioinform
     rescue
       false
     end
-
-    class TemporaryWrapper
-      attr_reader :input
-      include Bioinform::Parser::ClassMethods
-      include Bioinform::Parser::SingleMotifParser::ClassMethods
-      def initialize(parser)
-        @parser, input = parser, input
-      end
-      def parse
-        @parser.parse(@input)
-      end
-      def parse!
-        @parser.parse!(@input)
-      end
-      def new(input)
-        @input = input
-        self
-      end
-    end
-
-    def wrapper
-      TemporaryWrapper.new(self)
-    end
   end
 end

data/lib/bioinform/parsers/motif_splitter.rb

@@ -0,0 +1,45 @@
+module Bioinform
+  #
+  # MotifSpliiter is designed to split text into chunks with separate motifs.
+  # It enumerates input line by line.
+  # One can supply two options:
+  #   * pattern for splitter `splitter_pattern`
+  #   * `start_motif_pattern` which can determine start of motif but doesn't
+  #     match within motif
+  # If specified pattern is nil, corresponding splitting is not applied.
+  # Paterns are applied by `#===` operator, thus both regexp or a Proc are
+  # valid options. Proc accepts a line and should return true if line is
+  # a splitter or is a motif start.
+  #
+  # Splitter method `#split` returns an array of strings. Each of returned
+  # strings represents a motif. Motifs exclude splitter but include motif 
+  # start, thus one can divide input both by lines which will be dismissed
+  # and by lines which will be retained.
+  #
+  class MotifSplitter
+    attr_reader :start_motif_pattern, :spliiter
+
+    def initialize(options={})
+      @start_motif_pattern = options.fetch(:start_motif_pattern, /^\s*([^-+\s\d.]+|>.*)/)
+      @splitter_pattern = options.fetch(:splitter_pattern, /^\s*$/)
+    end
+
+    def parts_divided_by_splitter(input)
+      return input  unless @splitter_pattern
+      input.each_line.chunk{|line| @splitter_pattern === line }.reject{|is_splitter, lines| is_splitter}.map{|is_splitter, lines| lines.join}
+    end
+
+    def parts_divided_by_motif_starts(input)
+      return input  unless @start_motif_pattern
+      input.each_line.slice_before(@start_motif_pattern).map{|motif_lines| motif_lines.join }
+    end
+
+    private :parts_divided_by_splitter, :parts_divided_by_motif_starts
+
+    def split(input)
+      parts_divided_by_splitter(input).map{|chunk|
+        parts_divided_by_motif_starts(chunk)
+      }.flatten.map(&:strip).reject(&:empty?)
+    end
+  end
+end

data/lib/bioinform/support.rb

@@ -1,18 +1,50 @@
-require_relative 'support/third_part/active_support/core_ext/string/filters'
-require_relative 'support/third_part/active_support/core_ext/hash/indifferent_access'
+require_relative 'support/strip_doc'
 
-require_relative 'support/collect_hash'
-require_relative 'support/delete_many'
-require_relative 'support/multiline_squish'
-require_relative 'support/same_by'
-require_relative 'support/inverf'
-require_relative 'support/deep_dup'
+module Bioinform
+  module Support
+    # element_indices([:A,:C,:G,:T])  ==>  {:A=>0, :C=>1, :G=>2, :T=>3}
+    def self.element_indices(arr)
+      arr.each_with_index.inject({}) {|hsh, (letter, index)| hsh.merge(letter => index) }
+    end
 
-require_relative 'support/partial_sums'
+    # hash_keys_permuted([0,1], :A)  ==>  {[0,1] => :A, [1,0] => :A}
+    def self.hash_keys_permuted(key, value)
+      key.permutation.inject({}){|hsh, perm| hsh.merge(perm => value) }
+    end
 
-require_relative 'support/array_zip'
-require_relative 'support/array_product'
+    # with_key_permutations({[0,1] => :A, [0,2] => :T})  ==>  {[0,1] => :A, [1,0] => :A, [0,2] => :T, [2,0]=>:T}
+    def self.with_key_permutations(hash)
+      hash.inject({}) {|h, (indices, letter)| h.merge( hash_keys_permuted(indices, letter) ) }
+    end
 
-require_relative 'support/advanced_scan'
-require_relative 'support/parameters'
-require_relative 'support/strip_doc'
+
+    # various_key_cases({'a' => 2, 'C' => 3, :g =>5, :T => 8})  ==>  {'a' => 2, 'A' => 2, 'c' => 3, 'C' => 3, :g =>5, :G => 5, :T => 8, :t=>8}
+    def self.various_key_cases(hash)
+      hash.inject({}){|h,(k,v)| h.merge(k.downcase => v, k.upcase => v) }
+    end
+
+    # various_key_types({'a' => 2, 'C' => 3, :g =>5, :T => 8})  ==>  {'a' => 2, :a => 2, 'C' => 3, :C => 3, :g =>5, 'g' => 5, :T => 8, 'T'=>8}
+    def self.various_key_types(hash)
+      hash.inject({}){|h,(k,v)| h.merge(k.to_s => v, k.to_sym => v) }
+    end
+
+    def self.various_key_case_types(hash)
+      various_key_types(various_key_cases(hash))
+    end
+
+
+    # various_key_value_cases({:A => :T})  ==>  {:A => :T, :a => :t}
+    def self.various_key_value_cases(hash)
+      hash.inject({}){|h,(k,v)| h.merge(k.upcase => v.upcase, k.downcase => v.downcase) }
+    end
+
+    # various_key_value_types({:A => :T})  ==>  {:A => :T, 'A' => 'T'}
+    def self.various_key_value_types(hash)
+      hash.inject({}){|h,(k,v)| h.merge(k.to_s => v.to_s, k.to_sym => v.to_sym) }
+    end
+
+    def self.various_key_value_case_types(hash)
+      various_key_value_types(various_key_value_cases(hash))
+    end
+  end
+end