mgnu 2.1.1

data/lib/mgnu/genbank/location.rb

@@ -0,0 +1,150 @@
+require 'mgnu/sequence'
+
+module MgNu
+  class Genbank
+    class Location
+      InvalidLocation = Class.new(StandardError)
+      LocationWithRemoteAccession = Class.new(StandardError)
+
+      BASERANGE_REGEX = /
+      (?<complement>complement)?\(?
+      (?<remote_accession>[A-Z\d\.]+:)?
+        (?<start_continues><)?
+        (?<start>\d+)\.\.
+        (?<stop_continues>>)?
+        (?<stop>\d+)
+      \)?/x
+
+      attr_accessor :raw_value, :start, :stop, :start_continues, :stop_continues
+      attr_accessor :complement, :type, :parts
+
+      # create a new Location object
+      def initialize(raw_value)
+        @raw_value = raw_value.gsub(/\s/, '')
+        parse_raw_value
+      end
+
+      # parsing the location from a loc line
+      def parse_raw_value
+        case raw_value
+        when /^complement\(join\((.+)\)/
+          @type = 'complement_with_join'
+          @complement = true
+          @parts = Regexp.last_match[1].split(/,/)
+          set_properties_for_join_types
+        when /^(?:join|order)\((.+)\)/
+          @type = 'join'
+          @parts = Regexp.last_match[1].split(/,/)
+          set_properties_for_join_types
+        when BASERANGE_REGEX
+          @type = 'standard'
+          set_basic_properties(raw_value)
+        when /^(\d+)\.(\d+)$/
+          @type = 'between_range'
+          @start, @stop = Regexp.last_match[1].to_i, Regexp.last_match[2].to_i
+        when /^(\d+)^(\d+)$/
+          @type = 'between_adjoining'
+          @start, @stop = Regexp.last_match[1].to_i, Regexp.last_match[2].to_i
+        when /^(complement)?\(?(\d+)\)?$/
+          @type = 'single'
+          @complement = !!Regexp.last_match[1]
+          @start = Regexp.last_match[2].to_i
+        else
+          fail InvalidLocation, 'This is not a valid Genbank location'
+        end
+      end
+
+      def set_properties_for_join_types
+        non_remote = parts.select { |part| part !~ /[A-Z\d\.]+:/ }
+        if non_remote.length == 1
+          set_basic_properties(non_remote.first)
+        else
+          @complement ||= !!(non_remote.first =~ /complement/)
+          # sets start and stop based on first and last non remote part, taking into account complement strand
+          stop_match, start_match = nil
+          if complement
+            stop_match = /(?<stop_continues><)?(?<stop>\d+)/.match(non_remote.first)
+            start_match = /\.\.(?<start_continues>>)?(?<start>\d+)/.match(non_remote.last)
+          else
+            start_match = /(?<start_continues><)?(?<start>\d+)/.match(non_remote.first)
+            stop_match = /\.\.(?<stop_continues>>)?(?<stop>\d+)/.match(non_remote.last)
+          end
+          @start = start_match[:start].to_i
+          @stop = stop_match[:stop].to_i
+          @start_continues = start_match[:start_continues]
+          @stop_continues = stop_match[:stop_continues]
+        end
+      end
+
+      def set_basic_properties(str)
+        md = BASERANGE_REGEX.match(str)
+        @complement ||= !!md[:complement]
+        @remote_accession = md[:remote_accession]
+        # start/stop continues takes into account the complement strand
+        @start = complement ? md[:stop].to_i : md[:start].to_i
+        @stop = complement ? md[:start].to_i : md[:stop].to_i
+        @start_continues = complement ? !!md[:stop_continues] : !!md[:start_continues]
+        @stop_continues = complement ? !!md[:start_continues] : !!md[:stop_continues]
+      end
+
+      def get_sequence(seq)
+        s = case type
+            when 'complement_with_join', 'join'
+              str = buidup_sequence_from_parts(seq)
+              str ? build_sequence(str) : nil
+            when 'standard'
+              if complement
+                build_sequence(seq[stop - 1 .. start - 1])
+              else
+                build_sequence(seq[start - 1 .. stop - 1])
+              end
+            when 'single'
+              build_sequence(seq[start - 1])
+            else
+              return nil
+            end
+
+        if s && ((%w(single standard).include?(type) && complement) || type == 'complement_with_join')
+          s.reverse_complement!
+        end
+        s
+      end
+
+      def buidup_sequence_from_parts(seq)
+        to_be_joined = ''
+        parts.each do |part|
+          md = BASERANGE_REGEX.match(part)
+          if md[:remote_accession]
+            return nil
+          else
+            temp = seq[md[:start].to_i - 1 .. md[:stop].to_i - 1]
+            temp.tr!('actg', 'tgac').reverse! if md[:complement]
+            to_be_joined += temp
+          end
+        end
+        to_be_joined
+      end
+
+      def build_sequence(str)
+        MgNu::Sequence.new(:value => str, :type => 'dna')
+      end
+
+      # string representation
+      def to_s
+        max = 79 - 21 # max length of location line
+        out = ''
+        if raw_value.length > max
+          split_str = raw_value.scan(/(.{1,#{max}})(,|$)/)
+          out += (split_str[0].first + split_str[0].last)
+          split_str[1 .. - 1].each do |a, b|
+            out << ("\n" + ' ' * 21 + a)
+            out << b unless b.empty?
+          end
+        else
+          out << raw_value
+        end
+        out
+      end
+    end # end of MgNu::Parser::Genbank::Location
+  end # end of MgNu::Parser::Genbank class
+end # end of MgNu module

data/lib/mgnu/genbank/qualifier.rb

@@ -0,0 +1,45 @@
+module MgNu
+  class Genbank
+    class Qualifier
+      include MgNu::Parser
+      attr_accessor :name, :value, :quoted
+
+      # create new Qualifier object
+      def initialize(opts = {})
+        @name = opts.key?(:name) ? strip_quotes(opts[:name]).downcase : nil
+        @value = opts.key?(:value) ? opts[:value] : nil
+        @quoted = opts.key?(:quoted) ? opts[:quoted] : false
+      end
+
+      # string representation
+      def to_s
+        out = ("\n" + ' ' * 21)
+        out << "/#{name}"
+        if value
+          out << '='
+          out << '"' if quoted
+          # calculate max length for first line of qualifier value
+          x = 79 - 21 - (name.length + 2) # length of name + equal sign
+          x -= 1 if quoted
+          if value.length > x
+            first_line_max = nil
+            x.downto(0).each do |i|
+              if value[i].chr =~ /[^\w-]/
+                first_line_max = i
+                break
+              end
+            end
+            first_line_max ||= x
+            out << value[0 .. first_line_max - 1]
+            out << "\n"
+            out << (' ' * 21 + value[first_line_max .. -1].print_multiline(79, :indent => 21).strip)
+          else
+            out << value
+          end
+          out << '"' if quoted
+        end
+        out
+      end
+    end # end
+  end # end Genbank class
+end # end MgNu module

data/lib/mgnu/genbank/reference.rb

@@ -0,0 +1,114 @@
+module MgNu
+  class Genbank
+    class Reference
+      attr_accessor :title, :number, :base_range, :authors, :journal
+      attr_accessor :consrtm, :pubmed, :remark
+
+      # create a new Reference object
+      def initialize
+        @title = nil
+        @base_range = nil
+        @number = nil
+        @authors = []
+        @consrtm = nil
+        @journal = nil
+        @pubmed = nil
+        @remark = nil
+      end
+
+      # REFERENCE   1  (bases 1 to 9334)
+      #   AUTHORS   Morowitz,M.J., Denef,V.J., Costello,E.K., Thomas,B.C., Relman,D.A.
+      #             and Banfield,J.F.
+      #   TITLE     Direct Submission
+      #   JOURNAL   Submitted (08-APR-2011) Earth and Planetary Sciences, University of
+      #             California - Berkeley, 369 McCone Hall, Berkeley, CA 94720, USA
+      #   REMARK    Strain-resolved community genomic analysis of gut microbial
+      #             colonization in a premature infant
+
+      # class method to parse raw ref line
+      def self.parse(raw_string)
+        ref = Reference.new
+        buffer = raw_string.split("\n")
+        buffer.each_with_index do |line, i|
+          line.chomp!
+          if line =~ /^REFERENCE\s+(\d+)/
+            ref.number = Regexp.last_match[1].to_i
+            if line =~ /\(bases (\d+) to (\d+)\)/
+              ref.base_range = Range.new(Regexp.last_match[1].to_i, Regexp.last_match[2].to_i)
+            end
+          elsif line =~ /AUTHORS\s+(.+)/
+            author_line = Regexp.last_match[1]
+            while next_line = buffer[i + 1]
+              if next_line =~ /^\s*[A-Z]+\s/ # break if next sub-header line reached
+                break
+              else
+                author_line += next_line
+                buffer.delete_at(i + 1)
+              end
+            end
+            # process author_line
+            authors = author_line.split(/,\s+/)
+            last_author = authors.pop
+            authors += last_author.split(/\s*and\s*/)
+            ref.authors = authors
+          elsif line =~ /^\s*([A-Z]+)\s+(.+)/
+            type, content_line = Regexp.last_match[1], Regexp.last_match[2]
+            next unless ref.respond_to?(type.downcase.to_sym)
+            while next_line = buffer[i + 1]
+              if next_line =~ /^\s*[A-Z]+\s/
+                break
+              else
+                content_line += next_line
+                buffer.delete_at(i + 1)
+              end
+            end
+            # process content_line
+            ref.send(:"#{type.downcase}=", content_line.strip.squeeze(' '))
+          end
+        end
+        ref
+      end
+
+      def to_s
+        out = ''
+        out += "#{'REFERENCE'.ljust(12)}#{number}"
+        if base_range
+          out += number.to_s.length == 1 ? '  ' : ' '
+          out += "(bases #{base_range.first} to #{base_range.last})\n"
+        else
+          out += "\n"
+        end
+        if authors.any?
+          out += "  #{'AUTHORS'.ljust(10)}"
+          case authors.length
+          when 1
+            out += authors[0]
+          when 2
+            out += "#{authors[0]} and #{authors[1]}"
+          else
+            out += "#{authors[0...-1].join(', ')} and #{authors[-1]}".print_multiline
+          end
+          out += "\n" unless [consrtm, title, journal, remark].none?
+        end
+        if consrtm
+          out += "  #{'CONSRTM'.ljust(10)}#{consrtm.print_multiline}"
+          out += "\n" unless [title, journal, remark].none?
+        end
+        if title
+          out += "  #{'TITLE'.ljust(10)}#{title.print_multiline}"
+          out += "\n" unless [journal, remark].none?
+        end
+        if journal
+          out += "  #{'JOURNAL'.ljust(10)}#{journal.print_multiline}"
+          out += "\n" unless [pubmed, remark].none?
+        end
+        out += "   #{'PUBMED'.ljust(9)}#{pubmed}" if pubmed
+        if remark
+          out += "\n"
+          out += "  #{'REMARK'.ljust(10)}#{remark.print_multiline}"
+        end
+        out
+      end
+    end # end MgNu::Parser::Genbank::Reference class
+  end # end of MgNu::Parser::Genbank class
+end # end of MgNu module

data/lib/mgnu/genbank/source.rb

@@ -0,0 +1,39 @@
+module MgNu
+  class Genbank
+    class Source
+      attr_accessor :organism, :common_name, :lineage
+
+      def initialize(common_name = nil, organism = '', lineage = '')
+        @common_name = common_name
+        @organism = organism
+        @lineage = lineage
+      end
+
+      # class method for parsing a buffer of Source data
+      def self.parse(buffer)
+        s = Source.new
+        buffer.each do |line|
+          if line =~ /^SOURCE\s+(.+)$/
+            s.common_name = Regexp.last_match[1].strip.squeeze(' ')
+          elsif line =~ /ORGANISM\s+(.+)/
+            s.organism += Regexp.last_match[1].strip.squeeze(' ')
+          elsif line =~ /[\w]+;\s/ # lineage line reached
+            temp = line.strip.squeeze(' ')
+            s.lineage += s.lineage.empty? ? temp : " #{temp}"
+          end
+        end
+        s.lineage.chop! if s.lineage =~ /(.+)\.$/ # remove period at the end
+        s
+      end
+
+      def to_s
+        out = ''
+        out << "#{'SOURCE'.ljust(12)}#{common_name}\n"
+        out << "  #{'ORGANISM'.ljust(10)}#{organism.print_multiline}\n"
+        out << ''.ljust(12) # first lineage line
+        out << lineage.print_multiline unless lineage.empty?
+        out << '.'
+      end
+    end # end MgNu::Parser::Genbank::Source class
+  end # end of MgNu::Parser::Genbank class
+end # end of MgNu module

data/lib/mgnu/loggable.rb

@@ -0,0 +1,61 @@
+require 'logger'
+
+module MgNu
+  class Logger < ::Logger
+    @@log = nil
+
+    def self.get
+      if not @@log
+        @@log = self.new(STDOUT)
+        @@log.level = MgNu::Logger::DEBUG
+      end
+      @@log
+    end # end Logger.get
+
+    def self.log=(log)
+      @@log = log
+    end # end Logger set
+
+    def level(new_level)
+      get if not @@log
+      case new_level
+      when "WARN"
+        @@log.level = MgNu::Logger::WARN
+      when "INFO"
+        @@log.level = MgNu::Logger::INFO
+      when "DEBUG"
+        @@log.level = MgNu::Logger::DEBUG
+      when "ERROR"
+        @@log.level = MgNu::Logger::ERROR
+      when "FATAL"
+        @@log.level = MgNu::Logger::FATAL
+      when "UNKNOWN"
+        @@log.level = MgNu::Logger::UNKNOWN
+      end
+    end
+
+  end # end MgNu::Logger class
+
+  # mixin to add logging to any class
+  module Loggable
+    def debug(msg)
+      MgNu::Logger.get.debug(msg)
+    end
+
+    def info(msg)
+      MgNu::Logger.get.info(msg)
+    end
+    def warn(msg)
+      MgNu::Logger.get.warn(msg)
+    end
+    def error(msg)
+      MgNu::Logger.get.error(msg)
+    end
+    def fatal(msg)
+      MgNu::Logger.get.fatal(msg)
+    end
+    def unknown(msg)
+      MgNu::Logger.get.unknown(msg)
+    end
+  end # end MgNu::Logger::Loggable module
+end # end MgNu module

data/lib/mgnu/parser.rb

@@ -0,0 +1,50 @@
+module MgNu
+  module Parser
+    require_relative 'parser/blast'
+    require_relative 'parser/clustalw'
+    require_relative 'parser/fasta'
+    require_relative 'parser/fasta_index'
+    require_relative 'parser/fasta_header_index'
+    require_relative 'parser/fastq'
+    require_relative 'parser/gff'
+    require_relative 'parser/genbank'
+    #require_relative 'parser/iprscan_file'
+    #require_relative 'parser/kegg_ontology_index'
+    #require_relative 'parser/sam'
+    #require_relative 'parser/pilercr'
+    require_relative 'parser/prodigal'
+
+    # Remove quotes from a string
+    #
+    # @param [String] input string to strip
+    # @return [String] input string with quotes removed
+    def strip_quotes(input)
+      input = Regexp.last_match[1] if input =~ /^["'](.+)["']$/
+      input
+    end
+
+    # Reads a file until the given regexp is found
+    #
+    # @param [File, Regexp, Bool] file object and regular expression to
+    #   search for and a boolean indicating whether or not to discard
+    #   the regexp line or push it back onto the file
+    # @return [Array] lines from file up to but NOT including the
+    #   regexp matchline
+    def parse_until(file, regexp, discard = true)
+      buffer = Array.new
+      file.each do |line|
+        if line =~ regexp and buffer.length != 0
+          # found exit condition
+          if discard
+            file.seek(-line.length, IO::SEEK_CUR) # push this line back on and return
+          end
+          return buffer
+        else
+          buffer << line.chomp
+        end
+      end # end of file.each do |line|
+      return buffer
+    end # end of parse_until
+
+  end # end of module Parser
+end # end of module MgNu