wwood-bioruby 1.2.11

data/lib/bio/db/embl/common.rb

@@ -0,0 +1,352 @@
+#
+# = bio/db/embl.rb - Common methods for EMBL style database classes
+#
+# Copyright::   Copyright (C) 2001-2006
+#               Mitsuteru C. Nakao <n@bioruby.org>
+# License::     The Ruby License
+#
+# $Id: common.rb,v 1.12.2.5 2008/05/07 12:22:10 ngoto Exp $
+#
+# == Description
+#
+# EMBL style databases class
+#
+# This module defines a common framework among EMBL, UniProtKB, SWISS-PROT, 
+# TrEMBL. For more details, see the documentations in each embl/*.rb 
+# libraries.
+#
+# EMBL style format:
+#     ID - identification             (begins each entry; 1 per entry)
+#     AC - accession number           (>=1 per entry)
+#     SV - sequence version           (1 per entry)
+#     DT - date                       (2 per entry)
+#     DE - description                (>=1 per entry)
+#     KW - keyword                    (>=1 per entry)
+#     OS - organism species           (>=1 per entry)
+#     OC - organism classification    (>=1 per entry)
+#     OG - organelle                  (0 or 1 per entry)
+#     RN - reference number           (>=1 per entry)
+#     RC - reference comment          (>=0 per entry)
+#     RP - reference positions        (>=1 per entry)
+#     RX - reference cross-reference  (>=0 per entry)
+#     RA - reference author(s)        (>=1 per entry)
+#     RG - reference group            (>=0 per entry)
+#     RT - reference title            (>=1 per entry)
+#     RL - reference location         (>=1 per entry)
+#     DR - database cross-reference   (>=0 per entry)
+#     FH - feature table header       (0 or 2 per entry)
+#     FT - feature table data         (>=0 per entry)
+#     CC - comments or notes          (>=0 per entry)
+#     XX - spacer line                (many per entry)
+#     SQ - sequence header            (1 per entry)
+#     bb - (blanks) sequence data     (>=1 per entry)
+#     // - termination line           (ends each entry; 1 per entry)
+#
+# == Examples
+# 
+#  # Make a new parser class for EMBL style database entry.
+#  require 'bio/db/embl/common'
+#  module Bio
+#    class NEWDB < EMBLDB
+#      include Bio::EMBLDB::Common
+#    end
+#  end
+#
+# == References
+#
+# * The EMBL Nucleotide Sequence Database
+#   http://www.ebi.ac.uk/embl/
+#
+# * The EMBL Nucleotide Sequence Database: Users Manual
+#   http://www.ebi.ac.uk/embl/Documentation/User_manual/usrman.html
+# 
+# * Swiss-Prot Protein knowledgebase. TrEMBL Computer-annotated supplement 
+#   to Swiss-Prot 
+#   http://au.expasy.org/sprot/
+# 
+# * UniProt 
+#   http://uniprot.org/
+# 
+# * The UniProtKB/SwissProt/TrEMBL User Manual 
+#   http://www.expasy.org/sprot/userman.html
+#
+
+require 'bio/db'
+require 'bio/reference'
+require 'bio/compat/references'
+
+module Bio
+class EMBLDB
+module Common
+
+  DELIMITER = "\n//\n"
+  RS = DELIMITER
+  TAGSIZE = 5
+
+  def initialize(entry)
+    super(entry, TAGSIZE)
+  end
+
+  # returns a Array of accession numbers in the AC lines.
+  #
+  # AC Line
+  #   "AC   A12345; B23456;"
+  #   AC [AC1;]+
+  #
+  # Accession numbers format:
+  #   1       2     3          4          5          6
+  #   [O,P,Q] [0-9] [A-Z, 0-9] [A-Z, 0-9] [A-Z, 0-9] [0-9]
+  def ac
+    unless @data['AC']
+      tmp = Array.new
+      field_fetch('AC').split(/ /).each do |e|
+        tmp.push(e.sub(/;/,''))
+      end
+      @data['AC'] = tmp
+    end
+    @data['AC']
+  end
+  alias accessions ac
+
+
+  # returns the first accession number in the AC lines
+  def accession
+    ac[0]
+  end
+
+
+  # returns a String int the DE line.
+  #
+  # DE Line
+  def de
+    unless @data['DE']
+      @data['DE'] = fetch('DE')
+    end
+    @data['DE']
+  end
+  alias description de
+  alias definition de   # API
+  
+
+
+  # returns contents in the OS line.
+  # * Bio::EMBLDB#os  -> Array of <OS Hash>
+  # where <OS Hash> is:
+  #  [{'name'=>'Human', 'os'=>'Homo sapiens'}, 
+  #   {'name'=>'Rat', 'os'=>'Rattus norveticus'}]
+  # * Bio::SPTR#os[0]['name'] => "Human"
+  # * Bio::SPTR#os[0] => {'name'=>"Human", 'os'=>'Homo sapiens'}
+  # * Bio::STPR#os(0) => "Homo sapiens (Human)"
+  #
+  # OS Line; organism species (>=1)
+  #   "OS   Trifolium repens (white clover)"
+  #
+  #   OS   Genus species (name).
+  #   OS   Genus species (name0) (name1).
+  #   OS   Genus species (name0) (name1).
+  #   OS   Genus species (name0), G s0 (name0), and G s (name1).
+  def os(num = nil)
+    unless @data['OS']
+      os = Array.new
+      fetch('OS').split(/, and|, /).each do |tmp|
+        if tmp =~ /([A-Z][a-z]* *[\w\d \:\'\+\-]+[\w\d])/
+          org = $1
+          tmp =~ /(\(.+\))/ 
+          os.push({'name' => $1, 'os' => org})
+        else
+          raise "Error: OS Line. #{$!}\n#{fetch('OS')}\n"
+        end
+      end
+      @data['OS'] = os
+    end
+    if num
+      # EX. "Trifolium repens (white clover)"
+      "#{@data['OS'][num]['os']} {#data['OS'][num]['name']"
+    end
+    @data['OS']
+  end
+
+
+  # returns contents in the OG line.
+  # * Bio::EMBLDB::Common#og  -> [ <ogranella String>* ]
+  #
+  # OG Line; organella (0 or 1/entry)
+  #  OG   Plastid; Chloroplast.
+  #  OG   Mitochondrion.
+  #  OG   Plasmid sym pNGR234a.
+  #  OG   Plastid; Cyanelle.
+  #  OG   Plasmid pSymA (megaplasmid 1).
+  #  OG   Plasmid pNRC100, Plasmid pNRC200, and Plasmid pHH1.
+  def og
+    unless @data['OG']
+      og = Array.new
+      if get('OG').size > 0
+        ogstr = fetch('OG')
+        ogstr.sub!(/\.$/,'')
+        ogstr.sub!(/ and/,'')
+        ogstr.sub!(/;/, ',')
+        ogstr.split(',').each do |tmp|
+          og.push(tmp.strip)
+        end
+      end
+      @data['OG'] = og
+    end
+    @data['OG']
+  end
+  
+
+  # returns contents in the OC line.
+  # * Bio::EMBLDB::Common#oc  -> [ <organism class String>* ]
+  # OC Line; organism classification (>=1)
+  #  OC   Eukaryota; Alveolata; Apicomplexa; Piroplasmida; Theileriidae;
+  #  OC   Theileria.
+  def oc
+    unless @data['OC']
+      begin
+        @data['OC'] = fetch('OC').sub(/.$/,'').split(/;/).map {|e|
+          e.strip 
+        }
+      rescue NameError
+        nil
+      end
+    end
+    @data['OC']
+  end
+
+  # returns keywords in the KW line.
+  # * Bio::EMBLDB::Common#kw  -> [ <keyword>* ]
+  # KW Line; keyword (>=1)
+  #  KW   [Keyword;]+
+  def kw
+    unless @data['KW']
+      if get('KW').size > 0
+        tmp = fetch('KW').sub(/.$/,'')
+        @data['KW'] = tmp.split(/;/).map {|e| e.strip }
+      else
+        @data['KW'] = []
+      end
+    end
+    @data['KW']
+  end
+  alias keywords kw
+
+
+  # returns contents in the R lines.
+  # * Bio::EMBLDB::Common#ref -> [ <refernece information Hash>* ]
+  # where <reference information Hash> is:
+  #  {'RN' => '', 'RC' => '', 'RP' => '', 'RX' => '', 
+  #   'RA' => '', 'RT' => '', 'RL' => '', 'RG' => ''}
+  # 
+  # R Lines
+  # * RN RC RP RX RA RT RL RG
+  def ref
+    unless @data['R']
+      ary = Array.new
+      get('R').split(/\nRN   /).each do |str|
+        raw = {'RN' => '', 'RC' => '', 'RP' => '', 'RX' => '', 
+               'RA' => '', 'RT' => '', 'RL' => '', 'RG' => ''}
+        str = 'RN   ' + str unless /^RN   / =~ str
+        str.split("\n").each do |line|
+          if /^(R[NPXARLCTG])   (.+)/ =~ line
+            raw[$1] += $2 + ' '
+          else
+            raise "Invalid format in R lines, \n[#{line}]\n"
+          end
+        end
+        raw.each_value {|v| 
+          v.strip! 
+          v.sub!(/^"/,'')
+          v.sub!(/;$/,'')
+          v.sub!(/"$/,'')
+        }
+        ary.push(raw)
+      end
+      @data['R'] = ary
+    end
+    @data['R']
+  end
+
+  # returns Bio::Reference object from Bio::EMBLDB::Common#ref.
+  # * Bio::EMBLDB::Common#ref -> Bio::References
+  def references
+    unless @data['references']
+      ary = self.ref.map {|ent|
+        hash = Hash.new
+        ent.each {|key, value|
+          case key
+          when 'RN'
+            if /\[(\d+)\]/ =~ value.to_s
+              hash['embl_gb_record_number'] = $1.to_i
+            end
+          when 'RC'
+            unless value.to_s.strip.empty?
+              hash['comments'] ||= []
+              hash['comments'].push value
+            end
+          when 'RP'
+            hash['sequence_position'] = value
+          when 'RA'
+            a = value.split(/\, /)
+            a.each do |x|
+              x.sub!(/( [^ ]+)\z/, ",\\1")
+            end
+            hash['authors'] = a
+          when 'RT'
+            hash['title'] = value
+          when 'RL'
+            if /(.*) (\d+) *(\(([^\)]+)\))?(\, |\:)([a-zA-Z\d]+\-[a-zA-Z\d]+) *\((\d+)\)\.?\z/ =~ value.to_s
+              hash['journal'] = $1.rstrip
+              hash['volume']  = $2
+              hash['issue']   = $4
+              hash['pages']   = $6
+              hash['year']    = $7
+            else
+              hash['journal'] = value
+            end
+          when 'RX'  # PUBMED, DOI, (AGRICOLA)
+            value.split(/\. /).each {|item|
+              tag, xref = item.split(/\; /).map {|i| i.strip.sub(/\.\z/, '') }
+              hash[ tag.downcase ]  = xref
+            }
+          end
+        }
+        Reference.new(hash)
+      }
+      @data['references'] = ary.extend(Bio::References::BackwardCompatibility)
+    end
+    @data['references']
+  end
+
+
+  # returns contents in the DR line.
+  # * Bio::EMBLDB::Common#dr  -> [ <Database cross-reference Hash>* ]
+  # where <Database cross-reference Hash> is:
+  # * Bio::EMBLDB::Common#dr {|k,v| } 
+  # 
+  # DR Line; defabases cross-reference (>=0)
+  # a cross_ref pre one line
+  #  "DR  database_identifier; primary_identifier; secondary_identifier."
+  def dr
+    unless @data['DR']
+      tmp = Hash.new
+      self.get('DR').split(/\n/).each do |db|
+        a = db.sub(/^DR   /,'').sub(/.$/,'').strip.split(/;[ ]/)
+        dbname = a.shift
+        tmp[dbname] = Array.new unless tmp[dbname]
+        tmp[dbname].push(a)
+      end
+      @data['DR'] = tmp
+    end
+    if block_given?
+      @data['DR'].each do |k,v|
+        yield(k, v)
+      end
+    else
+      @data['DR']
+    end
+  end
+
+end # module Common
+end # class EMBLDB
+end # module Bio
+

data/lib/bio/db/embl/embl.rb

@@ -0,0 +1,500 @@
+#
+# = bio/db/embl/embl.rb - EMBL database class
+#
+# 
+# Copyright::   Copyright (C) 2001-2007
+#               Mitsuteru C. Nakao <n@bioruby.org>
+#               Jan Aerts <jan.aerts@bbsrc.ac.uk>
+# License::     The Ruby License
+#
+# $Id: embl.rb,v 1.29.2.7 2008/06/17 16:04:36 ngoto Exp $
+#
+# == Description
+#
+# Parser class for EMBL database entry.
+#
+# == Examples
+# 
+#   emb = Bio::EMBL.new($<.read)
+#   emb.entry_id
+#   emb.each_cds do |cds|
+#     cds # A CDS in feature table.
+#   end
+#   emb.seq #=> "ACGT..."
+#
+# == References
+#
+# * The EMBL Nucleotide Sequence Database
+#   http://www.ebi.ac.uk/embl/
+#
+# * The EMBL Nucleotide Sequence Database: Users Manual
+#   http://www.ebi.ac.uk/embl/Documentation/User_manual/usrman.html
+#
+
+require 'date'
+require 'bio/db'
+require 'bio/db/embl/common'
+require 'bio/compat/features'
+require 'bio/compat/references'
+require 'bio/sequence'
+require 'bio/sequence/dblink'
+
+module Bio
+class EMBL < EMBLDB
+  include Bio::EMBLDB::Common
+
+  # returns contents in the ID line.
+  # * Bio::EMBL#id_line -> <ID Hash>
+  # where <ID Hash> is:
+  #  {'ENTRY_NAME' => String, 'MOLECULE_TYPE' => String, 'DIVISION' => String,
+  #   'SEQUENCE_LENGTH' => Int, 'SEQUENCE_VERSION' => Int}
+  #
+  # ID Line
+  #  "ID  ENTRY_NAME DATA_CLASS; MOLECULE_TYPE; DIVISION; SEQUENCE_LENGTH BP."
+  #
+  # DATA_CLASS = ['standard']
+  #
+  # MOLECULE_TYPE: DNA RNA XXX
+  #
+  # Code ( DIVISION )
+  #  EST (ESTs)
+  #  PHG (Bacteriophage)
+  #  FUN (Fungi)
+  #  GSS (Genome survey)
+  #  HTC (High Throughput cDNAs) 
+  #  HTG (HTGs)
+  #  HUM (Human)
+  #  INV (Invertebrates)
+  #  ORG (Organelles)
+  #  MAM (Other Mammals)
+  #  VRT (Other Vertebrates)
+  #  PLN (Plants)
+  #  PRO (Prokaryotes)
+  #  ROD (Rodents)
+  #  SYN (Synthetic)
+  #  STS (STSs)
+  #  UNC (Unclassified)
+  #  VRL (Viruses)
+  #
+  # Rel 89-
+  # ID   CD789012; SV 4; linear; genomic DNA; HTG; MAM; 500 BP.
+  # ID <1>; SV <2>; <3>; <4>; <5>; <6>; <7> BP.
+  # 1. Primary accession number
+  # 2. Sequence version number
+  # 3. Topology: 'circular' or 'linear'
+  # 4. Molecule type (see note 1 below)
+  # 5. Data class (see section 3.1)
+  # 6. Taxonomic division (see section 3.2)
+  # 7. Sequence length (see note 2 below)
+  def id_line(key=nil)
+    unless @data['ID']
+      tmp = Hash.new
+      idline = fetch('ID').split(/; +/)         
+      tmp['ENTRY_NAME'], tmp['DATA_CLASS'] = idline.shift.split(/ +/)
+      if idline.first =~ /^SV/
+        tmp['SEQUENCE_VERSION'] = idline.shift.split(' ').last
+        tmp['TOPOLOGY'] = idline.shift
+        tmp['MOLECULE_TYPE'] = idline.shift
+        tmp['DATA_CLASS'] = idline.shift
+      else
+        tmp['MOLECULE_TYPE'] = idline.shift
+      end
+      tmp['DIVISION'] = idline.shift
+      tmp['SEQUENCE_LENGTH'] = idline.shift.strip.split(' ').first.to_i
+
+      @data['ID'] = tmp
+    end
+    
+    if key
+      @data['ID'][key]
+    else
+      @data['ID']
+    end
+  end
+
+  # returns ENTRY_NAME in the ID line.
+  # * Bio::EMBL#entry -> String
+  def entry
+    id_line('ENTRY_NAME')
+  end
+  alias entry_name entry
+  alias entry_id entry
+
+  # returns MOLECULE_TYPE in the ID line.
+  # * Bio::EMBL#molecule -> String
+  def molecule
+    id_line('MOLECULE_TYPE')
+  end
+  alias molecule_type molecule
+
+  def data_class
+    id_line('DATA_CLASS')
+  end
+  
+  def topology
+    id_line('TOPOLOGY')
+  end
+  
+  # returns DIVISION in the ID line.
+  # * Bio::EMBL#division -> String
+  def division
+    id_line('DIVISION')
+  end
+
+  # returns SEQUENCE_LENGTH in the ID line.
+  # * Bio::EMBL#sequencelength -> String
+  def sequence_length
+    id_line('SEQUENCE_LENGTH')
+  end
+  alias seqlen sequence_length
+  
+
+  # AC Line
+  # "AC   A12345; B23456;"
+
+
+  # returns the version information in the sequence version (SV) line.
+  # * Bio::EMBL#sv -> Accession.Version in String
+  # * Bio::EMBL#version -> accession in Int
+  #
+  # SV Line; sequence version (1/entry)
+  #  SV    Accession.Version
+  def sv
+    if (v = field_fetch('SV').sub(/;/,'')) == ""
+      [id_line['ENTRY_NAME'], id_line['SEQUENCE_VERSION']].join('.') 
+    else
+      v
+    end  
+  end
+  def version
+    (sv.split(".")[1] || id_line['SEQUENCE_VERSION']).to_i
+  end
+
+  
+  # returns contents in the date (DT) line.
+  # * Bio::EMBL#dt  -> <DT Hash>
+  # where <DT Hash> is:
+  #  {}
+  # * Bio::EMBL#dt(key)  -> String
+  # keys: 'created' and 'updated'
+  #
+  # DT Line; date (2/entry)
+  def dt(key=nil)
+    unless @data['DT']
+      tmp = Hash.new
+      dt_line = self.get('DT').split(/\n/)
+      tmp['created'] = dt_line[0].sub(/\w{2}   /,'').strip
+      tmp['updated'] = dt_line[1].sub(/\w{2}   /,'').strip
+      @data['DT'] = tmp
+    end
+    if key
+      @data['DT'][key]
+    else
+      @data['DT']
+    end
+  end
+
+
+
+  ##
+  # DE Line; description (>=1)
+  #
+
+
+  ##
+  # KW Line; keyword (>=1)
+  # KW   [Keyword;]+
+  #
+  # Bio::EMBLDB#kw  -> Array
+  #            #keywords  -> Array
+
+
+  ##
+  # OS Line; organism species (>=1)
+  # OS   Genus species (name)
+  # "OS   Trifolium repens (white clover)"
+  #
+  # Bio::EMBLDB#os  -> Array
+
+
+  ##
+  # OC Line; organism classification (>=1)
+  #
+  # Bio::EMBLDB#oc  -> Array
+
+
+  ##
+  # OG Line; organella (0 or 1/entry)
+  # ["Mitochondrion", "Chloroplast","Kinetoplast", "Cyanelle", "Plastid"]
+  #  or a plasmid name (e.g. "Plasmid pBR322").  
+  #
+  # Bio::EMBLDB#og  -> String
+
+
+  ##
+  # R Lines
+  # RN RC RP RX RA RT RL
+  #
+  # Bio::EMBLDB#ref
+  
+  
+  ##
+  # DR Line; defabases cross-regerence (>=0)
+  # "DR  database_identifier; primary_identifier; secondary_identifier."
+  #
+  # Bio::EMBLDB#dr
+
+
+  # returns feature table header (String) in the feature header (FH) line.
+  #
+  # FH Line; feature table header (0 or 2)
+  def fh
+    fetch('FH')
+  end
+
+  # returns contents in the feature table (FT) lines.
+  # * Bio::EMBL#ft -> Bio::Features
+  # * Bio::EMBL#ft {} -> {|Bio::Feature| }
+  #
+  # same as features method in bio/db/genbank.rb 
+  #
+  # FT Line; feature table data (>=0)
+  def ft
+    unless @data['FT']
+      ary = Array.new
+      in_quote = false
+      @orig['FT'].each_line do |line|
+        next if line =~ /^FEATURES/
+
+        head = line[0,20].strip  # feature key (source, CDS, ...)
+        body = line[20,60].chomp # feature value (position, /qualifier=)
+        if line =~ /^FT {3}(\S+)/
+          ary.push([ $1, body ]) # [ feature, position, /q="data", ... ]
+        elsif body =~ /^ \// and not in_quote
+          ary.last.push(body)    # /q="data..., /q=data, /q
+
+          if body =~ /=" / and body !~ /"$/
+            in_quote = true
+          end
+
+        else
+          ary.last.last << body # ...data..., ...data..."
+
+          if body =~ /"$/
+            in_quote = false
+          end
+        end
+      end
+
+      ary.map! do |subary|
+        parse_qualifiers(subary)
+      end
+
+      @data['FT'] = ary.extend(Bio::Features::BackwardCompatibility)
+    end
+    if block_given?
+      @data['FT'].each do |feature|
+        yield feature
+      end
+    else
+      @data['FT']
+    end
+  end
+  alias features ft
+
+  # iterates on CDS features in the FT lines.
+  def each_cds
+    ft.each do |cds_feature|
+      if cds_feature.feature == 'CDS'
+        yield cds_feature
+      end
+    end
+  end
+
+  # iterates on gene features in the FT lines.
+  def each_gene
+    ft.each do |gene_feature|
+      if gene_feature.feature == 'gene'
+        yield gene_feature
+      end
+    end
+  end
+
+
+  # returns comment text in the comments (CC) line.
+  #
+  # CC Line; comments of notes (>=0)
+  def cc
+    get('CC').to_s.gsub(/^CC   /, '')
+  end
+  alias comment cc
+
+  ##
+  # XX Line; spacer line (many)
+  #  def nxx
+  #  end
+
+
+  # returns sequence header information in the sequence header (SQ) line.
+  # * Bio::EMBL#sq  -> <SQ Hash>
+  # where <SQ Hash> is:
+  #     {'ntlen' => Int, 'other' => Int,
+  #      'a' => Int, 'c' => Int, 'g' => Int, 't' => Int}
+  # * Bio::EMBL#sq(base)  -> <base content in Int>
+  # * Bio::EMBL#sq[base]  -> <base content in Int>
+  #
+  # SQ Line; sequence header (1/entry)
+  #  SQ   Sequence 1859 BP; 609 A; 314 C; 355 G; 581 T; 0 other;
+  def sq(base = nil)
+    unless @data['SQ']
+      fetch('SQ') =~ \
+             /(\d+) BP\; (\d+) A; (\d+) C; (\d+) G; (\d+) T; (\d+) other;/
+      @data['SQ'] = {'ntlen' => $1.to_i, 'other' => $6.to_i,
+                     'a' => $2.to_i, 'c' => $3.to_i , 'g' => $4.to_i, 't' => $5.to_i}
+    else
+      @data['SQ']
+    end
+
+    if base
+      @data['SQ'][base.downcase]
+    else
+      @data['SQ']
+    end
+  end
+  
+
+  # returns the nucleotie sequence in this entry.
+  # * Bio::EMBL#seq  -> Bio::Sequence::NA
+  #
+  # @orig[''] as sequence
+  # bb Line; (blanks) sequence data (>=1)
+  def seq
+    Bio::Sequence::NA.new( fetch('').gsub(/ /,'').gsub(/\d+/,'') )
+  end
+  alias naseq seq
+  alias ntseq seq
+
+  #--
+  # // Line; termination line (end; 1/entry)
+  #++
+
+  # modified date. Returns Date object, String or nil.
+  def date_modified
+    parse_date(self.dt['updated'])
+  end
+
+  # created date. Returns Date object, String or nil.
+  def date_created
+    parse_date(self.dt['created'])
+  end
+
+  # release number when last updated
+  def release_modified
+    parse_release_version(self.dt['updated'])[0]
+  end
+
+  # release number when created
+  def release_created
+    parse_release_version(self.dt['created'])[0]
+  end
+
+  # entry version number numbered by EMBL
+  def entry_version
+    parse_release_version(self.dt['updated'])[1]
+  end
+
+  # parse date string. Returns Date object.
+  def parse_date(str)
+    begin
+      Date.parse(str)
+    rescue ArgumentError, TypeError, NoMethodError, NameError
+      str
+    end
+  end
+  private :parse_date
+
+  # extracts release and version numbers from DT line
+  def parse_release_version(str)
+    return [ nil, nil ] unless str
+    a = str.split(/[\(\,\)]/)
+    dstr = a.shift
+    rel = nil
+    ver = nil
+    a.each do |x|
+      case x
+      when /Rel\.\s*(.+)/
+        rel = $1.strip
+      when /Version\s*(.+)/
+        ver = $1.strip
+      end
+    end
+    [ rel, ver ]
+  end
+  private :parse_release_version
+
+  # database references (DR).
+  # Returns an array of Bio::Sequence::DBLink objects.
+  def dblinks
+    get('DR').split(/\n/).collect { |x|
+      Bio::Sequence::DBLink.parse_embl_DR_line(x)
+    }
+  end
+
+  # species
+  def species
+    self.fetch('OS')
+  end
+
+  # taxonomy classfication
+  alias classification oc
+
+  # features
+  alias features ft
+
+
+  # converts the entry to Bio::Sequence object
+  # ---
+  # *Arguments*::
+  # *Returns*:: Bio::Sequence object
+  def to_biosequence
+    Bio::Sequence.adapter(self, Bio::Sequence::Adapter::EMBL)
+  end
+
+  ### private methods
+
+  private
+
+  ##
+  # same as Bio::GenBank#parse_qualifiers(feature)
+  def parse_qualifiers(ary)
+    feature = Feature.new
+
+    feature.feature = ary.shift
+    feature.position = ary.shift.gsub(/\s/, '')
+
+    ary.each do |f|
+      if f =~ %r{/([^=]+)=?"?([^"]*)"?}
+        qualifier, value = $1, $2
+        
+        if value.empty?
+          value = true
+        end
+
+        case qualifier
+        when 'translation'
+          value = Sequence::AA.new(value.gsub(/\s/, ''))
+        when 'codon_start'
+          value = value.to_i
+        end
+
+        feature.append(Feature::Qualifier.new(qualifier, value))
+      end
+    end
+
+    return feature
+  end
+
+end # class EMBL
+
+end # module Bio
+