bioinform 0.1.17 → 0.2.0

data/lib/bioinform/data_models/collection.rb

@@ -1,75 +0,0 @@
-require 'ostruct'
-require_relative 'motif'
-
-module Bioinform
-  class Collection
-    attr_accessor :container
-
-    include Parameters
-    make_parameters :name
-
-    # collection name is a tag name for each motif in a collection. But motif can be included in several collections so have several tags
-    def initialize(parameters = {})
-      @container = []
-      @parameters = OpenStruct.new(parameters)
-      yield @parameters  if block_given?
-    end
-
-    def size
-      container.size
-    end
-
-    def to_s(with_name = true)
-      result = (with_name) ? "Collection: #{name.to_s}\n" : ''
-      each do |pm, infos|
-        result << pm.to_s << "\n\n"
-      end
-      result
-    end
-
-    def +(other)
-      result = self.class.new
-      container.each do |motif|
-        result.container << motif
-      end
-      other.container.each do |motif|
-        result.container << motif
-      end
-      result
-    end
-
-    def add_pm(pm, info)
-#      pm.mark(self)
-      container << Motif.new(info.marshal_dump.merge(pm: pm))
-      #### What if pm already is a Motif
-      self
-    end
-
-    def <<(pm)
-      add_pm(pm, OpenStruct.new)
-    end
-
-    # collection.each{|motif| ... }
-    # collection.each(:pwm, :threshold){|pwm,threshold| }
-    def each(*args)
-      if block_given?
-        if args.empty?
-          container.each{|motif| yield motif}
-        else
-          container.each{|motif| yield( *args.map{|arg| motif.parameters.send(arg)} ) }
-        end
-      else
-        self.to_enum(:each, *args)
-      end
-    end
-
-    include Enumerable
-
-    def ==(other)
-      (parameters == other.parameters) && (container == other.container)
-    rescue
-      false
-    end
-
-  end
-end

data/lib/bioinform/data_models/motif.rb

@@ -1,56 +0,0 @@
-require 'ostruct'
-require_relative '../support/third_part/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/formatters/raw_formatter.rb

@@ -1,41 +0,0 @@
-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/parsers/jaspar_parser.rb

@@ -1,35 +0,0 @@
-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/parser.rb

@@ -1,92 +0,0 @@
-require 'ostruct'
-require_relative '../support'
-require_relative '../data_models/pm'
-require_relative 'splittable_parser'
-
-module Bioinform
-  class Error < StandardError; end
-  class ParsingError < Error; end
-  class InvalidMatrix < Error; end
-  
-  class Parser
-    attr_reader :input
-
-    def initialize(*input)
-      if input.size == 1  # [ [1,2,3,4] ],  [  [[1,2,3,4],[5,6,7,8]] ]
-        if input.first.is_a?(Array) && input.first.all?{|el| el.is_a? Numeric}  # [ [1,2,3,4] ]
-          @input = input
-        else  # [  [[1,2,3,4],[5,6,7,8]] ]
-          @input = input.first
-        end
-      else #[ [1,2,3,4], [5,6,7,8] ], [   ]
-        @input = input
-      end
-    end
-
-    def parse!
-      matrix = self.class.transform_input(input)
-      raise InvalidMatrix unless self.class.valid_matrix?(matrix)
-      OpenStruct.new(matrix: matrix)
-    end
-
-    def parse
-      parse! rescue nil
-    end
-
-    module ClassMethods
-      def choose(input, data_model = PM)
-        data_model.choose_parser(input).new(input)
-      end
-
-      def parse!(*input)
-        new(*input).parse!
-      end
-      def parse(*input)
-        new(*input).parse
-      end
-
-      def valid_matrix?(matrix)
-        PM.valid_matrix?(matrix)
-      end
-
-      # {A: 1, C: 2, G: 3, T: 4}  -->  [1,2,3,4]
-      # {A: [1,2], C: [3,4], G: [5,6], T: [7,8]}  --> [[1,3,5,7],[2,4,6,8]] ( == [[1,2], [3,4], [5,6], [7,8]].transpose)
-      def array_from_acgt_hash(hsh)
-        hsh = normalize_hash_keys(hsh)
-        raise 'some of hash keys A,C,G,T are missing or hash has excess keys' unless hsh.keys.sort == [:A,:C,:G,:T]
-        result = [:A,:C,:G,:T].collect{|letter| hsh[letter] }
-        result.all?{|el| el.is_a?(Array)} ? result.transpose : result
-      end
-
-      # {a: 1, C: 2, 'g' => 3, 'T' => 4} --> {A: 1, C: 2, G: 3, T: 4}
-      def normalize_hash_keys(hsh)
-        hsh.collect_hash{|key,value| [key.to_s.upcase.to_sym, value] }
-      end
-
-      # [[1,2,3,4], [2,3,4,5]] --> [[1,2,3,4], [2,3,4,5]]
-      # [{A:1, C:2, G:3, T:4}, {A:2, C:3, G:4, T:5}] --> [{A:1, C:2, G:3, T:4}, {A:2, C:3, G:4, T:5}]
-      # {:A => [1,2,3], :c => [2,3,4], 'g' => [3,4,5], 'T' => [4,5,6]} --> [[1,2,3],[2,3,4],[3,4,5],[4,5,6]].transpose
-      def try_convert_to_array(input)
-        case input
-        when Array then input
-        when Hash then array_from_acgt_hash(input)
-        else raise TypeError, 'input of Bioinform::Parser::array_from_acgt_hash should be Array or Hash'
-        end
-      end
-
-      def transform_input(input)
-        result = try_convert_to_array(input).map{|el| try_convert_to_array(el)}
-        need_tranpose?(result) ? result.transpose : result
-      end
-
-      # point whether matrix input positions(need not be transposed -- false) or letters(need -- true) as first index
-      # [[1,3,5,7], [2,4,6,8]] --> false
-      # [[1,2],[3,4],[5,6],[7,8]] --> true
-      def need_tranpose?(input)
-        (input.size == 4) && input.any?{|x| x.size != 4}
-      end
-    end
-
-    extend ClassMethods
-  end
-end

data/lib/bioinform/parsers/splittable_parser.rb

@@ -1,57 +0,0 @@
-module Bioinform
-  class Parser
-    module SingleMotifParser
-      def self.included(base)
-        base.class_eval { extend ClassMethods }
-        include Enumerable
-        alias_method :split, :to_a
-      end
-      module ClassMethods
-        def split_on_motifs(input, pm_klass = PM)
-          [ input.is_a?(pm_klass) ? self : pm_klass.new(input, self) ]
-        end
-      end
-      def each
-        if block_given?
-          yield self
-        else
-          self.to_enum(:each)
-        end
-      end
-    end
-    include SingleMotifParser
-
-    module MultipleMotifsParser
-      def self.included(base)
-        base.class_eval { extend ClassMethods }
-        include Enumerable
-        alias_method :split, :to_a
-      end
-      module ClassMethods
-        def split_on_motifs(input, pm_klass = PM)
-          split(input).map{|el| el.is_a?(pm_klass) ? el : pm_klass.new(el)}
-        end
-        def split(input)
-          self.new(input).split
-        end
-        private :split
-      end
-
-      def scanner_reset
-      end
-
-      def each
-        if block_given?
-          scanner_reset
-          while result = parse
-            yield result
-          end
-        else
-          self.to_enum(:each)
-        end
-      end
-
-      private :scanner_reset
-    end
-  end
-end

data/lib/bioinform/parsers/string_fantom_parser.rb

@@ -1,35 +0,0 @@
-require_relative '../support'
-require_relative '../parsers/string_parser'
-
-module Bioinform
-  class StringFantomParser < StringParser
-    def header_pat
-      /NA (?<name>[\w.+:-]+)\n[\w\d]+ A C G T.*\n/
-    end
-
-    def row_pat
-      /[\w\d]+ (?<row>(#{number_pat} )*#{number_pat})\n?/
-    end
-
-    def scan_splitter
-      scanner.scan(/(\/\/\n)+/)
-    end
-
-    def parse_matrix
-      matrix = []
-      while row_string = scan_row
-        matrix << split_row(row_string)[0,4]
-      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

@@ -1,72 +0,0 @@
-require 'strscan'
-require_relative '../support'
-require_relative '../parsers/parser'
-
-module Bioinform
-  class StringParser < Parser
-    include MultipleMotifsParser
-    attr_reader :scanner, :row_acgt_markers
-
-    def initialize(input)
-      raise ArgumentError, 'StringParser should be initialized with a String'  unless input.is_a?(String)
-      super
-      @scanner = StringScanner.new(input.gsub(/[[:blank:]]/,' ').multiline_squish)
-    end
-
-    def number_pat
-      /[+-]?\d+(\.\d+)?([eE][+-]?\d{1,3})?/
-    end
-
-    def header_pat
-      />?\s*(?<name>\S+)\n/
-    end
-
-    def row_pat
-      /([ACGT]\s*[:|]?\s*)?(?<row>(#{number_pat} )*#{number_pat})\n?/
-    end
-
-    def scan_row
-      match = scanner.advanced_scan(row_pat)
-      match && match[:row]
-    end
-
-    def split_row(row_string)
-      row_string.split.map(&:to_f)
-    end
-
-    def scan_any_spaces
-      scanner.scan(/\s+/)
-    end
-
-    def parse_name
-      match = scanner.advanced_scan(header_pat)
-      match && match[:name]
-    end
-
-    def parse_matrix
-      matrix = []
-      @row_acgt_markers = true  if scanner.check(/A.*\nC.*\nG.*\nT.*\n?/)
-      while row_string = scan_row
-        matrix << split_row(row_string)
-      end
-      matrix
-    end
-
-    def parse_acgt_header
-      scanner.scan(/A\s*C\s*G\s*T\s*\n/i)
-    end
-
-    def parse!
-      scan_any_spaces
-      name = parse_name
-      parse_acgt_header
-      matrix = parse_matrix
-      matrix = matrix.transpose if row_acgt_markers
-      Parser.parse!(matrix).tap{|result| result.name = name}
-    end
-
-    def scanner_reset
-      scanner.reset
-    end
-  end
-end