mgnu 2.1.1

data/lib/mgnu/parser/fasta_index.rb

@@ -0,0 +1,57 @@
+require 'moneta'
+require 'json'
+
+module MgNu
+  module Parser
+    class FastaIndex
+      attr_reader :filename, :db_name, :db, :db_type
+
+      # create a new FastaIndex parser
+      def initialize(filename, options = {})
+        options = {
+          :db_type => :TokyoCabinet
+        }.merge!(options)
+
+        @db_type = options[:db_type]
+
+        @filename = filename
+        if @db_type == :TokyoCabinet
+          if @filename =~ /^.+\.tch$/
+            @db_name = @filename
+          else
+            @db_name = "#{@filename}.tch"
+          end
+        end
+
+        if db_type == :TokyoCabinet
+          @db = Moneta.new(:TokyoCabinet, file: @db_name, type: :hdb)
+        end
+        parse
+      end
+
+      # setup parse method for creating tokyo cabinet
+      def parse
+        MgNu::Parser::Fasta.new(@filename).each do |f|
+          name = f.header_name
+          description = f.header_description
+          @db[name] = { 'description' => description, 'sequence' => f.sequence }.to_json
+        end
+      end # end of #parse
+
+      def [](name)
+        f = nil
+        if @db.key?(name)
+          d = JSON.parse(@db[name])
+          f = MgNu::Sequence::Fasta.new(:header => "#{name} #{d['description']}",
+                                         :sequence => d['sequence'])
+        end
+        f
+      end
+
+      def close
+        @db.close unless @db.nil?
+      end
+
+    end # end of MgNu::Parser::FastaIndex class
+  end # end of MgNu::Parser module
+end # end of MgNu module

data/lib/mgnu/parser/fastq.rb

@@ -0,0 +1,61 @@
+module MgNu
+  module Parser
+    class Fastq
+      include Enumerable
+      attr_reader :file, :filename
+
+      # create a new Fastq parser
+      def initialize(filename = nil)
+        @filename = filename
+        if @filename
+          if File.exists?(@filename) and File.readable?(@filename)
+            @file = File.open(@filename)
+          else
+            raise "\n\n -- No file by that name (#{@filename}).  Exiting\n\n"
+            exit(1)
+          end
+        else
+          $stderr.puts("MgNu::Parser::Fastq.new(): need an existing fastq file name")
+          exit(1)
+        end
+      end
+
+      # override enumerables
+      def each
+        while @file.eof != true # keep reading until EOF
+          header = @file.readline.chomp
+          sequence = @file.readline.chomp
+          qualhdr = @file.readline.chomp
+          quality = @file.readline.chomp
+          if header =~ /^@(.*)/
+            header = $1
+            if qualhdr =~ /^\+(.*)/
+              qualhdr = $1
+            else
+              error("Malformed quality header!")
+              error("\n#{qualhdr}")
+              error("\nExiting at line #{@file.lineno}")
+              exit(1)
+            end
+            if header != qualhdr
+              if qualhdr =~ /\s*/
+                qualhdr = header
+              else
+                warn("Sequence header and quality header don't match!")
+                warn("sequence: #{header}")
+                warn(" quality: #{qualhdr}")
+              end
+            end
+            yield MgNu::Sequence::Fastq.new(:header => header, :sequence => sequence, :qualhdr => qualhdr, :quality => quality)
+          else
+            $stderr.puts "Malformed header!"
+            $stderr.puts "\n#{header}"
+            $stderr.puts "\nExiting at line #{@file.lineno}"
+            exit(1)
+          end
+        end # end of while @file.eof
+      end # end of #each
+
+    end # end of MgNu::Parser::Fasta class
+  end # end of MgNu::File module
+end # end of MgNu module

data/lib/mgnu/parser/genbank.rb

@@ -0,0 +1,187 @@
+module MgNu
+  module Parser
+    class Genbank
+      attr_reader :file
+      attr_accessor :genbank_instances
+
+      include MgNu::Loggable
+      include MgNu::Parser
+
+      InvalidGenbankFile = Class.new(StandardError)
+
+      LOCUS_REGEX = /^LOCUS\s+(\S+)\s+(\d+)\s+bp\s+(?:(ss-|ds-|ms-))?(\S+)\s+(?:(\S+)\s+)?(\S+)\s+(\S+)$/
+
+      # create a new Genbank parser
+      def initialize(filename)
+        @genbank_instances = []
+
+        if filename
+          if File.exists?(filename) and File.readable?(filename)
+            @file = File.open(filename)
+          else
+            error("MgNu::Parser::Genbank#parse: problems with filename")
+            raise "File doesn't exist or is not readable!"
+          end
+        else
+          error("MgNu::Parser::Genbank#parse: need a filename")
+          raise "no filename given!"
+        end
+      end
+
+      def parse(debug=false)
+        @debug = debug
+        # parse_header # also triggers parsing of everything else
+        until file.eof? do
+          parse_section
+        end
+        genbank_instances
+      end
+
+      def parse_section
+        locus_line = file.readline
+        if md = locus_line.match(LOCUS_REGEX)
+          genbank = MgNu::Genbank.new
+          info("found a LOCUS line") if @debug
+          genbank.locus = MgNu::Genbank::Locus.new(*md.captures)
+          info("LOCUS name #{genbank.locus.name}") if @debug
+
+          buffer = parse_until(file, /^ACCESSION/)
+          if buffer.join =~ /^DEFINITION\s+(.+)$/m
+            genbank.definition = $1.gsub(/\n/, ' ').gsub(/\s{2,}/, ' ').strip.chop 
+            info genbank.definition if @debug
+          end
+
+          buffer = parse_until(file, /^VERSION/)
+          # parsing ACESSION number line
+          if buffer.join =~ /^ACCESSION\s+(.+)$/
+            temp = $1.strip.squeeze(' ').split("\s") 
+            # multiple secondary accession numbers possible
+            genbank.accession, genbank.secondary_accession = temp.shift, temp
+          end
+          info "ACCESSION: #{genbank.accession}" if @debug
+
+          buffer = parse_until(file, /^KEYWORDS/)
+          # parsing VERSION line
+          buffer.each do |line|
+            if line =~ /^VERSION\s+(.+)$/
+              temp = $1.strip.squeeze(' ').split
+              temp.each do |version|
+                if version =~ /GI:(\d+)/
+                  genbank.geninfo_identifier = $1.to_i
+                else
+                  genbank.version = version
+                end
+              end
+            elsif line =~ /^DBLINK\s+(.+)$/
+              genbank.dblink = $1.strip.squeeze(' ')
+            end
+          end
+
+          buffer = parse_until(file, /^SOURCE/)
+
+          # parse keywords and optional segment
+          keyword_lines = []  
+          buffer.each do |line|
+            if line =~ /^KEYWORDS\s+(.+)$/
+              keyword_lines << $1.strip.squeeze(' ')
+            elsif line =~ /^SEGMENT\s+(.+)$/
+              genbank.segment = $1.strip.squeeze(' ')
+            else
+              keyword_lines << line
+            end
+          end
+          k = keyword_lines.join
+          unless k == "."
+            k_array = k.split(/;\s*/) # keywords are separated by semicolons
+            k_array[-1].chop! # gets rid of the period after the last keyword
+            genbank.keywords = k_array
+          end
+
+          buffer = parse_until(file,/^FEATURES/)
+
+          ri = buffer.index {|l| l =~ /^REFERENCE/ }
+          ci = buffer.index {|l| l =~ /^COMMENT/ }         
+
+          if ri && ci
+            genbank.source = MgNu::Genbank::Source.parse(buffer[0..ri-1])
+            parse_references(buffer[ri..ci-1], genbank)
+            genbank.comment = buffer[ci..-1].map{|line| line.gsub(/^COMMENT/, '').lstrip!.squeeze(' ')}.join("\n")
+          elsif ri
+            genbank.source = MgNu::Genbank::Source.parse(buffer[0..ri-1])
+            parse_references(buffer[ri..-1], genbank)
+          elsif ci
+            genbank.source = MgNu::Genbank::Source.parse(buffer[0..ci-1])
+            genbank.comment = buffer[ci..-1].map{|line| line.gsub(/^COMMENT/, '').lstrip!.squeeze(' ')}.join("\n")
+          else
+            # neither references nor comment line
+            genbank.source = MgNu::Genbank::Source.parse(buffer)
+          end
+            
+          info genbank.source.common_name if @debug
+          info genbank.source.organism if @debug
+          info genbank.source.lineage if @debug
+                        
+          parse_features(parse_until(file, /^ORIGIN/), genbank)
+          info "features count: #{genbank.features.length}" if @debug
+
+          parse_sequence(parse_until(file, /\/\//), genbank)
+          info "sequence length: #{genbank.sequence.try(:length) || 0}" if @debug
+          file.readline # consumes end of section line //
+          genbank_instances << genbank
+        else
+          unless locus_line =~ /^\s*$/
+            raise InvalidGenbankFile, "Missing or malformed LOCUS line."
+          end
+        end
+      end
+
+      def parse_features(buffer, genbank)
+        buffer.shift if buffer[0] =~ /^FEATURES/
+        all_features = split_at_features(buffer.join("\n"))
+
+        all_features.each do |feature_str|
+          genbank.features << MgNu::Genbank::Feature.parse(feature_str)
+        end
+      end # end parse_features
+
+      def parse_references(buffer, genbank)
+        ref_array = split_at_header_tag(buffer.join("\n"))
+        ref_array.each do |ref|
+          genbank.references << MgNu::Genbank::Reference.parse(ref)
+        end
+      end
+
+      def parse_sequence(buffer, genbank)
+        buffer.shift # drop ORIGIN line
+        info("inside parse_sequence") if @debug
+        info("buffer is #{buffer.length}") if @debug
+        
+        unless buffer.empty?
+          seq = ""
+          bigstr = buffer.join
+          seq = bigstr.gsub(/[\d\s]+/, "")
+          genbank.sequence = MgNu::Sequence.new(:value => seq)
+          genbank.features.each do |f|
+            f.sequence = f.location.get_sequence(genbank.sequence.value)
+          end
+        else 
+          genbank.sequence = nil
+        end
+      end
+
+      # splits at lines beginning with capital letter and no preceding space chars 
+      def split_at_header_tag(str)
+        sep = "\001"
+        str.gsub(/\n([A-Z])/, "\n#{sep}\\1").split(sep)
+      end  
+
+      def split_at_features(str)
+        sep = "\001"
+        str.gsub(/\n(\s{5}\S)/, "\n#{sep}\\1").split(sep)      
+      end 
+
+    end # end of MgNu::Parser::Genbank class
+  end # end of MgNu::Parser module
+end # end of MgNu module
+
+__END__

data/lib/mgnu/parser/gff.rb

@@ -0,0 +1,56 @@
+module MgNu
+  module Parser
+    class GFF
+      include Enumerable
+
+      attr_reader :file
+
+      # create a new GFF parser
+      def initialize(filename = nil)
+        if filename
+          if File.exists?(filename) and File.readable?(filename)
+            @file = File.open(filename)
+          else
+            @file = File.new(filename, "w")
+          end
+        else
+          error("MgNu::Parser::GFF.new(): need a filename for an existing file")
+        end
+      end
+
+      # override enumerables
+      def each
+        @file.each_line do |line|
+          line.chomp!
+          next if line =~ /^#/
+          yield Record.new(line)
+        end
+      end # end of #each
+
+      # class to deal with each line (record) of data
+      class Record
+        attr_accessor :name, :source, :feature, :start, :end
+        attr_accessor :score, :strand, :frame, :attributes
+
+        def initialize(line)
+          @name, @source, @feature, @start, @end,
+            @score, @strand, @frame, @attributes = line.split("\t")
+          @attributes = parse_attributes(attributes) if attributes
+        end
+        
+        alias :seqname :name
+
+        private
+
+        def parse_attributes(attributes)
+          hash = Hash.new
+          attributes.split(/[^\\];/).each do |atr|
+            key, value = atr.split(' ', 2)
+            hash[key] = value
+          end
+          hash
+        end
+      end # end of MgNu::Parser::GFF::Record class
+    end # end of MgNu::Parser::GFF class
+  end # end of MgNu::Parser module
+end # end of MgNu module

data/lib/mgnu/parser/iprscan/hit.rb

@@ -0,0 +1,76 @@
+module MgNu
+  module Parser
+    class Iprscan
+      class Hit
+        attr_accessor :query, :crc, :length, :db, :db_id, :db_description
+        attr_accessor :from, :to, :evalue, :status, :date
+        attr_accessor :ipr_id, :ipr_description, :go
+
+        include MgNu::Loggable
+
+        # create a new Hit object
+        def initialize(line = nil)
+          @ipr_id = nil
+          @ipr_description = nil
+          @go = nil
+
+          line.chomp!
+          temp = line.split(/\t/)
+          @query = temp.shift
+          @crc = temp.shift
+          @length = temp.shift.to_i
+          @db = temp.shift
+          @db_id = temp.shift
+          @db_description = temp.shift
+          @from = temp.shift.to_i
+          @to = temp.shift.to_i
+          @evalue = temp.shift.to_f
+          if @db == "Seg" or @db == "TMHMM" or @db == "Coil"
+            @evalue = "NA"
+          end
+          @status = temp.shift
+          @date = temp.shift
+          if temp.length > 0
+            @ipr_id = temp.shift
+            if temp.length > 0
+              @ipr_description = temp.shift
+              if temp.length > 0
+                @go = temp.shift
+              end
+            end
+          end
+
+        end
+
+        def to_s
+          str  = "#{@query}\t#{@crc}\t#{@length}\t#{@db}\t#{@db_id}\t#{@db_description}\t"
+          str += "#{@from}\t#{@to}\t#{@evalue}\t#{@status}\t#{@date}"
+          unless @ipr_id.nil?
+            str += "\t#{@ipr_id}\t#{@ipr_description}"
+            unless @go.nil?
+              str += "\t#{@go}"
+            end
+          end
+          str
+        end
+
+        def match_length
+          @from < @to ? @to - @from : @from - @to
+        end
+
+        def summary
+          string  = "#{@db_description} (db=#{@db} db_id=#{@db_id}"
+          string += " from=#{@from} to=#{@to}"
+          string += " evalue=#{@evalue}" unless db == "Seg" or db == "TMHMM"
+          string += " interpro_id=#{@ipr_id} interpro_description=#{@ipr_description}" unless @ipr_id == "NULL"
+          string += " GO=#{@go}" unless @go.nil?
+          string += ")"
+          string
+        end
+
+      end
+    end # end of MgNu::Parser::Iprscan::Hit class
+  end # end of MgNu::Parser module
+end # end of MgNu module
+
+__END__

data/lib/mgnu/parser/iprscan_file.rb

@@ -0,0 +1,39 @@
+require 'mgnu/parser/iprscan/hit'
+
+module MgNu
+  module Parser
+    class IprscanFile
+      attr_reader :file, :queries
+
+      include MgNu::Loggable
+
+      def initialize(filename = nil)
+        if filename
+          if File.exists?(filename) and File.readable?(filename)
+            @file = File.open(filename)
+          else
+            error("MgNu::Parser::IprscanFile.new(): problems with filename")
+            raise "File doesn't exist or is not readable!"
+          end
+        else
+          error("MgNu::Parser::IprscanFile.new(): need a filename")
+          raise "no filename given!"
+        end
+
+        @queries = Hash.new
+
+        parse
+      end
+
+      def parse
+        @file.each do |line|
+          line.chomp!
+          hit = MgNu::Parser::Iprscan::Hit.new(line)
+          @queries.has_key?(hit.query) ? @queries[hit.query] << hit : @queries[hit.query] = [ hit ]
+        end
+      end
+    end # end of MgNu::Parser::IprscanFile class
+  end # end of MgNu::Parser module
+end # end of MgNu module
+
+__END__