bio 1.0.0 → 1.1.0

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

@@ -1,10 +1,10 @@
 #
 # = bio/db/embl/sptr.rb - UniProt/SwissProt and TrEMBL database class
 # 
-# Copyright::   Copyright (C) 2001-2005 Mitsuteru C. Nakao <n@bioruby.org>
-# License::     LGPL
+# Copyright::   Copyright (C) 2001-2006  Mitsuteru C. Nakao <n@bioruby.org>
+# License::     The Ruby License
 #
-# $Id: sptr.rb,v 1.30 2006/01/28 06:40:38 nakao Exp $
+# $Id: sptr.rb,v 1.36 2007/04/05 23:35:40 trevor Exp $
 #
 # == Description
 # 
@@ -31,24 +31,7 @@
 # * The UniProtKB/SwissProt/TrEMBL User Manual
 #   http://www.expasy.org/sprot/userman.html
 #
-#--
-#
-#  This library is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU Lesser General Public
-#  License as published by the Free Software Foundation; either
-#  version 2 of the License, or (at your option) any later version.
-#
-#  This library is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-#  Lesser General Public License for more details.
-#
-#  You should have received a copy of the GNU Lesser General Public
-#  License along with this library; if not, write to the Free Software
-#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
-#
-#++
-#
+
 
 require 'bio/db'
 require 'bio/db/embl/common'
@@ -62,7 +45,6 @@ class SPTR < EMBLDB
   @@entry_regrexp = /[A-Z0-9]{1,4}_[A-Z0-9]{1,5}/
   @@data_class = ["STANDARD", "PRELIMINARY"]
 
-  
   # returns a Hash of the ID line.
   #
   # returns a content (Int or String) of the ID line by a given key.
@@ -73,30 +55,25 @@ class SPTR < EMBLDB
   #   #"ID  #{ENTRY_NAME} #{DATA_CLASS}; #{MOLECULE_TYPE}; #{SEQUENCE_LENGTH}."
   #
   # === Examples
-  #   obj.id_line  #=> {"ENTRY_NAME"=>"P53_HUMAN", "DATA_CLASS"=>"STANDARD", "SEQUENCE_LENGTH"=>393, "MOLECULE_TYPE"=>"PRT"}
+  #   obj.id_line  #=> {"ENTRY_NAME"=>"P53_HUMAN", "DATA_CLASS"=>"STANDARD", 
+  #                     "SEQUENCE_LENGTH"=>393, "MOLECULE_TYPE"=>"PRT"}
   #
   #   obj.id_line('ENTRY_NAME') #=> "P53_HUMAN"
   #
   def id_line(key = nil)
-    unless @data['ID']
-      tmp = Hash.new
-      a = @orig['ID'].split(/ +/)         
-      tmp['ENTRY_NAME']      = a[1]
-      tmp['DATA_CLASS']      = a[2].sub(/;/,'') 
-      tmp['MOLECULE_TYPE']   = a[3].sub(/;/,'')
-      tmp['SEQUENCE_LENGTH'] = a[4].to_i
-      @data['ID'] = tmp
-    end
-
-    if key
-      @data['ID'][key] # String/Int
-    else
-      @data['ID']      # Hash
-    end
+    return id_line[key] if key
+    return @data['ID'] if @data['ID']
+
+    part = @orig['ID'].split(/ +/)         
+    @data['ID'] = {
+      'ENTRY_NAME'      => part[1],
+      'DATA_CLASS'      => part[2].sub(/;/,''),
+      'MOLECULE_TYPE'   => part[3].sub(/;/,''),
+      'SEQUENCE_LENGTH' => part[4].to_i 
+    }
   end
 
 
-
   # returns a ENTRY_NAME in the ID line. 
   #
   def entry_id
@@ -144,20 +121,15 @@ class SPTR < EMBLDB
   #   DT DD-MMM-YYY (rel. NN, Last sequence update)
   #   DT DD-MMM-YYY (rel. NN, Last annotation update)
   def dt(key = nil)
-    unless @data['DT']
-      tmp = Hash.new
-      a = self.get('DT').split(/\n/)
-      tmp['created']    = a[0].sub(/\w{2}   /,'').strip
-      tmp['sequence']   = a[1].sub(/\w{2}   /,'').strip
-      tmp['annotation'] = a[2].sub(/\w{2}   /,'').strip
-      @data['DT'] = tmp
-    end
-
-    if key
-      @data['DT'][key]
-    else
-      @data['DT']
-    end
+    return dt[key] if key
+    return @data['DT'] if @data['DT']
+
+    part = self.get('DT').split(/\n/)
+    @data['DT'] = {
+      'created'    => part[0].sub(/\w{2}   /,'').strip,
+      'sequence'   => part[1].sub(/\w{2}   /,'').strip,
+      'annotation' => part[2].sub(/\w{2}   /,'').strip
+    }
   end
 
 
@@ -214,16 +186,18 @@ class SPTR < EMBLDB
   #
   # === GN Line: Gene name(s) (>=0, optional)
   def gn
-    return @data['GN'] if @data['GN']
-
-    case fetch('GN')
-    when /Name=/ then
-      return gn_uniprot_parser
-    else
-      return gn_old_parser
+    unless @data['GN']
+      case fetch('GN')
+      when /Name=/,/ORFNames=/
+        @data['GN'] = gn_uniprot_parser
+      else
+        @data['GN'] = gn_old_parser
+      end
     end
+    @data['GN']
   end
 
+
   # returns contents in the old style GN line.
   # === GN Line: Gene name(s) (>=0, optional)
   #  GN   HNS OR DRDX OR OSMZ OR BGLY.
@@ -245,7 +219,7 @@ class SPTR < EMBLDB
         }
       }
     end
-    return @data['GN'] = names
+    @data['GN'] = names
   end
   private :gn_old_parser
 
@@ -318,11 +292,13 @@ class SPTR < EMBLDB
   #  OS   Genus species (name0) (name1).
   #  OS   Genus species (name0), G s0 (name0), and G s (name0) (name1).
   #  OS   Homo sapiens (Human), and Rarrus norveticus (Rat)
+  #  OS   Hippotis sp. Clark and Watts 825.
+  #  OS   unknown cyperaceous sp.
   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])/
+        if tmp =~ /(\w+ *[\w\d \:\'\+\-\.]+[\w\d\.])/
           org = $1
           tmp =~ /(\(.+\))/ 
           os.push({'name' => $1, 'os' => org})
@@ -375,17 +351,224 @@ class SPTR < EMBLDB
     return @data['OX']
   end
 
+  # === The OH Line;  
+  #
+  # OH   NCBI_TaxID=TaxID; HostName.
+  # http://br.expasy.org/sprot/userman.html#OH_line
+  def oh
+    unless @data['OH']
+      @data['OH'] = fetch('OH').split("\. ").map {|x|
+        if x =~ /NCBI_TaxID=(\d+);/
+          taxid = $1
+        else
+          raise ArgumentError, ["Error: Invalid OH line format (#{self.entry_id}):",
+                                $!, "\n", get('OH'), "\n"].join
+          
+        end
+        if x =~ /NCBI_TaxID=\d+; (.+)/ 
+          host_name = $1
+          host_name.sub!(/\.$/, '')
+        else
+          host_name = nil
+        end
+        {'NCBI_TaxID' => taxid, 'HostName' => host_name}
+      }
+    end
+    @data['OH']
+  end
+
+
   
   # Bio::EMBLDB::Common#ref -> Array
   # R Lines
   # RN RC RP RX RA RT RL
 
+  # 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']
+      @data['R'] = [get('R').split(/\nRN   /)].flatten.map { |str|
+        hash = {'RN' => '', 'RC' => '', 'RP' => '', 'RX' => '', 
+               'RA' => '', 'RT' => '', 'RL' => '', 'RG' => ''}
+        str = 'RN   ' + str unless /^RN   / =~ str
+
+        str.split("\n").each do |line|
+          if /^(R[NPXARLCTG])   (.+)/ =~ line
+            hash[$1] += $2 + ' '
+          else
+            raise "Invalid format in R lines, \n[#{line}]\n"
+          end
+        end
+
+        hash['RN'] = set_RN(hash['RN'])
+        hash['RC'] = set_RC(hash['RC'])
+        hash['RP'] = set_RP(hash['RP'])
+        hash['RX'] = set_RX(hash['RX'])
+        hash['RA'] = set_RA(hash['RA'])
+        hash['RT'] = set_RT(hash['RT'])
+        hash['RL'] = set_RL(hash['RL'])
+        hash['RG'] = set_RG(hash['RG'])
+
+        hash
+      }
+
+    end
+    @data['R']
+  end
+
+  def set_RN(data)
+    data.strip
+  end
+
+  def set_RC(data)
+    data.scan(/([STP]\w+)=(.+);/).map { |comment|
+      [comment[1].split(/, and |, /)].flatten.map { |text|
+        {'Token' => comment[0], 'Text' => text}
+      }
+    }.flatten
+  end
+  private :set_RC
+
+  def set_RP(data)
+    data = data.strip
+    data = data.sub(/\.$/, '')
+    data.split(/, AND |, /i).map {|x| 
+      x = x.strip
+      x = x.gsub('  ', ' ')
+    }
+  end
+  private :set_RP
 
-  @@cc_topics = ['ALTERNATIVE PRODUCTS','CATALYTIC ACTIVITY','CAUTION',
-    'COFACTOR','DATABASE','DEVELOPMENTAL STAGE','DISEASE','DOMAIN',
-    'ENZYME REGULATION','FUNCTION','INDUCTION','MASS SPECTROMETRY',
-    'MISCELLANEOUS','PATHWAY','PHARMACEUTICAL','POLYMORPHISM','PTM',
-    'SIMILARITY','SUBCELLULAR LOCATION','SUBUNIT','TISSUE SPECIFICITY']
+  def set_RX(data)
+    rx = {'MEDLINE' => nil, 'PubMed' => nil, 'DOI' => nil}
+    if data =~ /MEDLINE=(.+?);/
+      rx['MEDLINE'] = $1
+    end
+    if data =~ /PubMed=(.+?);/
+      rx['PubMed'] = $1
+    end
+    if data =~ /DOI=(.+?);/
+      rx['DOI'] = $1
+    end
+    rx
+  end
+  private :set_RX
+
+  def set_RA(data)
+    data = data.sub(/; *$/, '')
+  end
+  private :set_RA
+
+  def set_RT(data)
+    data = data.sub(/; *$/, '')
+    data = data.gsub(/(^"|"$)/, '')
+  end
+  private :set_RT
+
+  def set_RL(data)
+    data = data.strip
+  end
+  private :set_RL
+
+  def set_RG(data)
+    data = data.split('; ')
+  end
+  private :set_RG
+
+
+
+  # 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 'RA'
+            hash['authors'] = value.split(/, /)
+          when 'RT'
+            hash['title'] = value
+          when 'RL'
+            if value =~ /(.*) (\d+) \((\d+)\), (\d+-\d+) \((\d+)\)$/
+              hash['journal'] = $1
+              hash['volume']  = $2
+              hash['issue']   = $3
+              hash['pages']   = $4
+              hash['year']    = $5
+            else
+              hash['journal'] = value
+            end
+          when 'RX'  # PUBMED, MEDLINE
+            value.split('.').each {|item|
+              tag, xref = item.split(/; /).map {|i| i.strip }
+              hash[ tag.downcase ]  = xref
+            }
+          end
+        }
+        Reference.new(hash)
+      }
+      @data['references'] = References.new(ary)
+    end
+    @data['references']
+  end
+
+
+
+
+
+
+  # === The HI line
+  # Bio::SPTR#hi #=> hash
+  def hi
+    unless @data['HI']
+      @data['HI'] = []
+      fetch('HI').split(/\. /).each do |hlist|
+        hash = {'Category' => '',  'Keywords' => [], 'Keyword' => ''}
+        hash['Category'], hash['Keywords'] = hlist.split(': ')
+        hash['Keywords'] = hash['Keywords'].split('; ')
+        hash['Keyword'] = hash['Keywords'].pop
+        hash['Keyword'].sub!(/\.$/, '')
+        @data['HI'] << hash
+      end
+    end
+    @data['HI']
+  end
+
+
+  @@cc_topics = ['PHARMACEUTICAL',
+                 'BIOTECHNOLOGY',
+                 'TOXIC DOSE', 
+                 'ALLERGEN',   
+                 'RNA EDITING',
+                 'POLYMORPHISM',
+                 'BIOPHYSICOCHEMICAL PROPERTIES',
+                 'MASS SPECTROMETRY',
+                 'WEB RESOURCE', 
+                 'ENZYME REGULATION',
+                 'DISEASE',
+                 'INTERACTION',
+                 'DEVELOPMENTAL STAGE',
+                 'INDUCTION',
+                 'CAUTION',
+                 'ALTERNATIVE PRODUCTS',
+                 'DOMAIN',
+                 'PTM',
+                 'MISCELLANEOUS',
+                 'TISSUE SPECIFICITY',
+                 'COFACTOR',
+                 'PATHWAY',
+                 'SUBUNIT',
+                 'CATALYTIC ACTIVITY',
+                 'SUBCELLULAR LOCATION',
+                 'FUNCTION',
+                 'SIMILARITY']
   # returns contents in the CC lines.
   # * Bio::SPTR#cc -> Hash
   #
@@ -425,27 +608,44 @@ class SPTR < EMBLDB
   #   CC   -!- TOPIC: FIRST LINE OF A COMMENT BLOCK;
   #   CC       SECOND AND SUBSEQUENT LINES OF A COMMENT BLOCK.
   #
-  def cc(tag = nil)
+  # See also http://www.expasy.org/sprot/userman.html#CC_line
+  #
+  def cc(topic = nil)
     unless @data['CC']
       cc  = Hash.new
-      cmt = '-' * (77 - 4 + 1)
+      comment_border= '-' * (77 - 4 + 1)
       dlm = /-!- /
 
-      return cc if get('CC').size == 0 # 12KD_MYCSM has no CC lines.
+      # 12KD_MYCSM has no CC lines.
+      return cc if get('CC').size == 0
+      
+      cc_raw = fetch('CC')
+
+      # Removing the copyright statement.
+      cc_raw.sub!(/ *---.+---/m, '')
+
+      # Not any CC Lines without the copyright statement.
+      return cc if cc_raw == ''
 
       begin
-        fetch('CC').split(/#{cmt}/)[0].sub(dlm,'').split(dlm).each do |tmp|
+        cc_raw, copyright = cc_raw.split(/#{comment_border}/)[0]
+        cc_raw = cc_raw.sub(dlm,'')
+        cc_raw.split(dlm).each do |tmp|
+          tmp = tmp.strip
+
           if /(^[A-Z ]+[A-Z]): (.+)/ =~ tmp
             key  = $1
-            body = $2.gsub(/- (?!AND)/,'-')
+            body = $2
+            body.gsub!(/- (?!AND)/,'-')
+            body.strip!
             unless cc[key]
               cc[key] = [body]
             else
               cc[key].push(body)
             end
           else
-            raise ["Error: [#{entry_id}]: CC Lines", '',
-                   tmp, '', '', fetch('CC'),''].join("\n")
+            raise ["Error: [#{entry_id}]: CC Lines", '"', tmp, '"',
+                   '', get('CC'),''].join("\n")
           end
         end
       rescue NameError
@@ -461,29 +661,62 @@ class SPTR < EMBLDB
       @data['CC'] = cc
     end
 
-    case tag
-    when 'ALTERNATIVE PRODUCTS'
-      ap = @data['CC']['ALTERNATIVE PRODUCTS'].to_s
-      return ap unless ap
-
-      # Event, Named isoforms, Comment, [Name, Synonyms, IsoId, Sequnce]+
-      tmp = {'Event' => nil, 'Named isoforms' => nil, 'Comment' => nil, 'Variants'  => []}
-
-      if /Event=(.+?);/ =~ ap
-        tmp['Event'] = $1
-      end
-      if /Named isoforms=(\S+?);/ =~ ap
-        tmp['Named isoforms'] = $1
-      end
-      if /Comment=(.+?);/m =~ ap
-        tmp['Comment'] = $1
-      end
-      ap.scan(/Name=.+?Sequence=.+?;/).each do |ent|
-        tmp['Variants'] << cc_ap_variants_parse(ent)
-      end
-      return tmp
-
 
+    case topic
+    when 'ALLERGEN'
+      return @data['CC'][topic]
+    when 'ALTERNATIVE PRODUCTS'
+      return cc_alternative_products(@data['CC'][topic])
+    when 'BIOPHYSICOCHEMICAL PROPERTIES'
+      return cc_biophysiochemical_properties(@data['CC'][topic])
+    when 'BIOTECHNOLOGY'
+      return @data['CC'][topic]
+    when 'CATALITIC ACTIVITY'
+      return cc_catalytic_activity(@data['CC'][topic])
+    when 'CAUTION'
+      return cc_caution(@data['CC'][topic])
+    when 'COFACTOR'
+      return @data['CC'][topic]
+    when 'DEVELOPMENTAL STAGE'
+      return @data['CC'][topic].to_s
+    when 'DISEASE'
+      return @data['CC'][topic].to_s
+    when 'DOMAIN'
+      return @data['CC'][topic]
+    when 'ENZYME REGULATION'
+      return @data['CC'][topic].to_s
+    when 'FUNCTION'
+      return @data['CC'][topic].to_s
+    when 'INDUCTION'
+      return @data['CC'][topic].to_s
+    when 'INTERACTION'
+      return cc_interaction(@data['CC'][topic])
+    when 'MASS SPECTROMETRY'
+      return cc_mass_spectrometry(@data['CC'][topic])
+    when 'MISCELLANEOUS'
+      return @data['CC'][topic]
+    when 'PATHWAY'
+      return cc_pathway(@data['CC'][topic])
+    when 'PHARMACEUTICAL'
+      return @data['CC'][topic]
+    when 'POLYMORPHISM'
+      return @data['CC'][topic]
+    when 'PTM'
+      return @data['CC'][topic]
+    when 'RNA EDITING'
+      return cc_rna_editing(@data['CC'][topic])
+    when 'SIMILARITY'
+      return @data['CC'][topic]
+    when 'SUBCELLULAR LOCATION'
+      return cc_subcellular_location(@data['CC'][topic])
+    when 'SUBUNIT'
+      return @data['CC'][topic]
+    when 'TISSUE SPECIFICITY'
+      return @data['CC'][topic]
+    when 'TOXIC DOSE'
+      return @data['CC'][topic]
+    when 'WEB RESOURCE'
+      return cc_web_resource(@data['CC'][topic])
     when 'DATABASE'
       # DATABASE: NAME=Text[; NOTE=Text][; WWW="Address"][; FTP="Address"].
       tmp = Array.new
@@ -507,73 +740,208 @@ class SPTR < EMBLDB
         tmp.push(db)
       end
       return tmp
-
-    when 'MASS SPECTOROMETRY'
-      # MASS SPECTROMETRY: MW=XXX[; MW_ERR=XX][; METHOD=XX][;RANGE=XX-XX].
-      tmp = Array.new
-      ms = @data['CC']['MASS SPECTOROMETRY']
-      return ms unless ms
-
-      ms.each do |m|
-        mass = {'MW'=>nil,'MW_ERR'=>nil,'METHOD'=>nil,'RANGE'=>nil}
-        m.sub(/.$/,'').split(/;/).each do |line|
-          case line
-          when /MW=(.+)/
-            mass['MW'] = $1.to_f
-          when /MW_ERR=(.+)/
-            mass['MW_ERR'] = $1.to_f
-          when /METHOD="(.+)"/
-            mass['METHOD'] = $1.to_s
-          when /RANGE="(\d+-\d+)"/ 
-            mass['RANGE'] = $1          # RANGE class ? 
-          end 
-        end
-        tmp.push(mass)
-      end
-      return tmp
-
-    when 'INTERACTION'
-      return cc_interaction_parse(@data['CC']['INTERACTION'].to_s)
-
     when nil
       return @data['CC']
-
     else
-      return @data['CC'][tag]
+      return @data['CC'][topic]
     end
   end
 
 
+  def cc_alternative_products(data)
+    ap = data.to_s
+    return ap unless ap
+
+    # Event, Named isoforms, Comment, [Name, Synonyms, IsoId, Sequnce]+
+    tmp = {'Event' => "", 'Named isoforms' => "", 'Comment' => "", 
+           'Variants'  => []}
+    if /Event=(.+?);/ =~ ap
+      tmp['Event'] = $1
+      tmp['Event'] = tmp['Event'].sub(/;/,'').split(/, /)
+    end
+    if /Named isoforms=(\S+?);/ =~ ap
+      tmp['Named isoforms'] = $1
+    end
+    if /Comment=(.+?);/m =~ ap
+      tmp['Comment'] = $1
+    end
+    ap.scan(/Name=.+?Sequence=.+?;/).each do |ent|
+      tmp['Variants'] << cc_alternative_products_variants(ent)
+    end
+    return tmp
+  end
+  private :cc_alternative_products
 
-  def cc_ap_variants_parse(ent)
-    hsh = {}
-    ent.split(/; /).map {|e| e.split(/=/) }.each do |e|
+  def cc_alternative_products_variants(data)
+    variant = {'Name' => '', 'Synonyms' => [], 'IsoId' => [], 'Sequence' => []}
+    data.split(/; /).map {|x| x.split(/=/) }.each do |e|
       case e[0]
-      when 'Sequence'
+      when 'Sequence', 'Synonyms', 'IsoId'
         e[1] = e[1].sub(/;/,'').split(/, /)
       end
-      hsh[e[0]] = e[1]
+      variant[e[0]] = e[1]
+    end
+    variant
+  end
+  private :cc_alternative_products_variants
+
+
+  def cc_biophysiochemical_properties(data)
+    data = data[0]
+
+    hash = {'Absorption' => {}, 
+            'Kinetic parameters' => {},
+            'pH dependence' => "",
+            'Redox potential' => "",
+            'Temperature dependence' => ""}
+    if data =~ /Absorption: Abs\(max\)=(.+?);/
+      hash['Absorption']['Abs(max)'] = $1
+    end
+    if data =~ /Absorption: Abs\(max\)=.+; Note=(.+?);/
+      hash['Absorption']['Note'] = $1
+    end
+    if data =~ /Kinetic parameters: KM=(.+?); Vmax=(.+?);/
+      hash['Kinetic parameters']['KM'] = $1
+      hash['Kinetic parameters']['Vmax'] = $2
     end
-    return hsh
+    if data =~ /Kinetic parameters: KM=.+; Vmax=.+; Note=(.+?);/
+      hash['Kinetic parameters']['Note'] = $1
+    end
+    if data =~ /pH dependence: (.+?);/
+      hash['pH dependence'] = $1
+    end
+    if data =~ /Redox potential: (.+?);/
+      hash['Redox potential'] = $1
+    end
+    if data =~ /Temperature dependence: (.+?);/
+      hash['Temperature dependence'] = $1
+    end
+    hash
+  end
+  private :cc_biophysiochemical_properties
+
+
+  def cc_caution(data)
+    data.to_s
   end
-  private :cc_ap_variants_parse
+  private :cc_caution
 
 
   # returns conteins in a line of the CC INTERACTION section.
   #
   #   CC       P46527:CDKN1B; NbExp=1; IntAct=EBI-359815, EBI-519280;
-  def cc_interaction_parse(str)
+  def cc_interaction(data)
+    str = data.to_s
     it = str.scan(/(.+?); NbExp=(.+?); IntAct=(.+?);/)
     it.map {|ent|
-      {:partner_id => ent[0].strip,
-       :nbexp => ent[1].strip, 
-       :intact_acc => ent[2].split(', ') }
+      ent.map! {|x| x.strip }
+      if ent[0] =~ /^(.+):(.+)/
+        spac = $1
+        spid = $2.split(' ')[0]
+        optid = nil
+      elsif ent[0] =~ /Self/
+        spac = self.entry_id
+        spid = self.entry_id
+        optid = nil
+      end
+      if ent[0] =~ /^.+:.+ (.+)/
+        optid = $1
+      end
+
+      {'SP_Ac' => spac,
+       'identifier' => spid,
+       'NbExp' => ent[1],
+       'IntAct' => ent[2].split(', '),
+       'optional_identifier' => optid}
+    }
+  end
+  private :cc_interaction
+
+
+  def cc_mass_spectrometry(data)
+    # MASS SPECTROMETRY: MW=XXX[; MW_ERR=XX][; METHOD=XX][;RANGE=XX-XX].
+    return data unless data
+
+    data.map { |m|
+      mass = {'MW' => nil, 'MW_ERR' => nil, 'METHOD' => nil, 'RANGE' => nil,
+              'NOTE' => nil}
+      m.sub(/.$/,'').split(/;/).each do |line|
+        case line
+        when /MW=(.+)/
+          mass['MW'] = $1
+        when /MW_ERR=(.+)/
+          mass['MW_ERR'] = $1
+        when /METHOD=(.+)/
+          mass['METHOD'] = $1
+        when /RANGE=(\d+-\d+)/ 
+          mass['RANGE'] = $1          # RANGE class ? 
+        when /NOTE=(.+)/
+          mass['NOTE'] = $1
+        end 
+      end
+      mass
+    }
+  end
+  private :cc_mass_spectrometry
+
+
+  def cc_pathway(data)
+    data.map {|x| x.sub(/\.$/, '') }.map {|x|
+      x.split(/; | and |: /)
+    }[0]
+  end
+  private :cc_pathway
+
+
+  def cc_rna_editing(data)
+ data = data.to_s
+    entry = {'Modified_positions' => [], 'Note' => ""}
+    if data =~ /Modified_positions=(.+?)(\.|;)/
+      entry['Modified_positions'] = $1.sub(/\.$/, '').split(', ')
+    else
+      raise ArgumentError, "Invarid CC RNA Editing lines (#{self.entry_id}):#{$!}\n#{get('CC')}"
+    end
+    if data =~ /Note=(.+)/
+      entry['Note'] = $1
+    end
+    entry
+  end
+  private :cc_rna_editing
+
+
+  def cc_subcellular_location(data)
+    data.map {|x| 
+      x.split('. ').map {|y| 
+        y.split('; ').map {|z| 
+          z.sub(/\.$/, '') 
+        } 
+      } 
+    }[0]
+  end
+  private :cc_subcellular_location
+
+  
+  # CC   -!- WEB RESOURCE: NAME=ResourceName[; NOTE=FreeText][; URL=WWWAddress].  
+  def cc_web_resource(data)
+    data.map {|x|
+      entry = {'NAME' => nil, 'NOTE' => nil, 'URL' => nil}
+      x.split(';').each do |y|
+        case y
+        when /NAME=(.+)/
+          entry['NAME'] = $1.strip
+        when /NOTE=(.+)/
+          entry['NOTE'] = $1.strip
+        when /URL="(.+)"/
+          entry['URL'] = $1.strip
+        end
+      end
+      entry
     }
   end
-  private :cc_interaction_parse
+  
 
   # returns databases cross-references in the DR lines.
-  # * Bio::EMBLDB#dr  -> Hash w/in Array
+  # * Bio::SPTR#dr  -> Hash w/in Array
   #
   # === DR Line; defabases cross-reference (>=0)
   #    DR  database_identifier; primary_identifier; secondary_identifier.
@@ -585,6 +953,24 @@ class SPTR < EMBLDB
     'PROSITE','REBASE','AARHUS/GHENT-2DPAGE','SGD','STYGENE','SUBTILIST',
     'SWISS-2DPAGE','TIGR','TRANSFAC','TUBERCULIST','WORMPEP','YEPD','ZFIN']
 
+  # Backup Bio::EMBLDB#dr as embl_dr
+  alias :embl_dr :dr 
+
+  # Bio::SPTR#dr
+  def dr(key = nil)
+    unless key
+      embl_dr
+    else
+      embl_dr[key].map {|x|
+        {'Accession' => x[0],
+         'Version' => x[1],
+         ' ' => x[2],
+         'Molecular Type' => x[3]}
+      }
+    end
+  end
+
+
   # Bio::EMBLDB::Common#kw - Array
   #                    #keywords  -> Array
   #
@@ -592,10 +978,29 @@ class SPTR < EMBLDB
   # KW   [Keyword;]+
 
 
-  # returns conteins in the feature table.
+  # returns contents in the feature table.
+  #
+  # == Examples
+  #
+  #  sp = Bio::SPTR.new(entry)
+  #  ft = sp.ft
+  #  ft.class #=> Hash
+  #  ft.keys.each do |feature_key|
+  #    ft[feature_key].each do |feature|
+  #      feature['From'] #=> '1'
+  #      feature['To']   #=> '21'
+  #      feature['Description'] #=> ''
+  #      feature['FTId'] #=> ''
+  #      feature['diff'] #=> []
+  #      feature['original'] #=> [feature_key, '1', '21', '', '']
+  #    end
+  #  end
+  #
   # * Bio::SPTR#ft -> Hash
-  #    {'feature_name' => [{'From' => str, 'To' => str,
-  #                         'Description' => str, 'FTId' => str}],...}
+  #    {FEATURE_KEY => [{'From' => int, 'To' => int, 
+  #                      'Description' => aStr, 'FTId' => aStr,
+  #                      'diff' => [original_residues, changed_residues],
+  #                      'original' => aAry }],...}
   #
   # returns an Array of the information about the feature_name in the feature table.
   # * Bio::SPTR#ft(feature_name) -> Array of Hash
@@ -611,106 +1016,87 @@ class SPTR < EMBLDB
   #   22-27   `TO' endpoint
   #   35-75   Description (>=0 per key)
   #   -----   -----------------
-  def ft(feature_name = nil)
-    unless @data['FT']
-      table        = Hash.new()
-      last_feature = nil
-
-      begin
-        get('FT').split(/\n/).each {|line|
-
-          feature = line[5..12].strip
+  #
+  # Note: 'FROM' and 'TO' endopoints are allowed to use non-numerial charactors 
+  # including '<', '>' or '?'. (c.f. '<1', '?42')
+  #
+  # See also http://www.expasy.org/sprot/userman.html#FT_line
+  #
+  def ft(feature_key = nil)
+    return ft[feature_key] if feature_key
+    return @data['FT'] if @data['FT']
 
-          if feature == '' and line[34..74]
-            tmp = ' ' + line[34..74].strip 
-            table[last_feature].last['Description'] << tmp
-            
-            next unless /\.$/ =~ line
-          else
-            from = line[14..19].strip
-            to   = line[21..26].strip
-            desc = line[34..74].strip if line[34..74]
-
-            table[feature] = [] unless table[feature]
-            table[feature] << {
-              'From'        => from.to_i, 
-              'To'          => to.to_i, 
-              'Description' => desc,
-              'diff'        => [],
-              'FTId'        => nil }
-            last_feature = feature
-            next
-          end
+    table = []
+    begin
+      get('FT').split("\n").each do |line|
+        if line =~ /^FT   \w/
+          feature = line.chomp.ljust(74)
+          table << [feature[ 5..12].strip,   # Feature Name
+                    feature[14..19].strip,   # From
+                    feature[21..26].strip,   # To
+                    feature[34..74].strip ]  # Description
+        else
+          table.last << line.chomp.sub!(/^FT +/, '')
+        end
+      end
 
-          case last_feature
-          when 'VARSPLIC', 'VARIANT', 'CONFLICT'
-            if /FTId=(.+?)\./ =~ line   # version 41 >
-              ftid = $1
-              table[last_feature].last['FTId'] = ftid
-              table[last_feature].last['Description'].sub!(/ \/FTId=#{ftid}./,'') 
-            end
+      # Joining Description lines
+      table = table.map { |feature| 
+        ftid = feature.pop if feature.last =~ /FTId=/
+        if feature.size > 4
+          feature = [feature[0], 
+                     feature[1], 
+                     feature[2], 
+                     feature[3, feature.size - 3].join(" ")]
+        end
+        feature << if ftid then ftid else '' end
+      }
 
-            case table[last_feature].last['Description']
-            when /(\w[\w ]*\w*) - ?> (\w[\w ]*\w*)/
-              original = $1
-              swap = $2
-              original = original.gsub(/ /,'').strip
-              swap = swap.gsub(/ /,'').strip
-            when /Missing/i
-              original = seq.subseq(table[last_feature].last['From'],
-                                    table[last_feature].last['To'])
-              swap = ''
-            else
-              raise line
-            end
-            table[last_feature].last['diff'] = [original, swap]
-          end
+      hash = {}
+      table.each do |feature|
+        hash[feature[0]] = [] unless hash[feature[0]]
+        hash[feature[0]] << {
+          # Removing '<', '>' or '?' in FROM/TO endopoint.
+          'From' => feature[1].sub(/\D/, '').to_i,  
+          'To'   => feature[2].sub(/\D/, '').to_i, 
+          'Description' => feature[3], 
+          'FTId' => feature[4].to_s.sub(/\/FTId=/, '').sub(/\.$/, ''),
+          'diff' => [],
+          'original' => feature
         }
 
-      rescue
-        raise "Invalid FT Lines(#{$!}) in #{entry_id}:, \n" + 
-                  "'#{self.get('FT')}'\n"
-      end
-
-      table.each_key do |k|
-        table[k].each do |e|
-          if / -> / =~ e['Description']
-            pattern = /([A-Z][A-Z ]*[A-Z]*) -> ([A-Z][A-Z ]*[A-Z]*)/
-            e['Description'].sub!(pattern) {  
-              a = $1
-              b = $2
-              a.gsub(/ /,'') + " -> " + b.gsub(/ /,'') 
-            }
-          end
-          if /- [\w\d]/ =~ e['Description']
-            e['Description'].gsub!(/([\w\d]- [\w\d]+)/) { 
-              a = $1
-              if /- AND/ =~ a
-                a
-              else
-                a.sub(/ /,'') 
-              end
-            }
+        case feature[0]
+        when 'VARSPLIC', 'VARIANT', 'VAR_SEQ', 'CONFLICT'
+          case hash[feature[0]].last['Description']
+          when /(\w[\w ]*\w*) - ?> (\w[\w ]*\w*)/
+            original_res = $1
+            changed_res = $2
+            original_res = original_res.gsub(/ /,'').strip
+            chenged_res = changed_res.gsub(/ /,'').strip
+          when /Missing/i
+            original_res = seq.subseq(hash[feature[0]].last['From'],
+                                      hash[feature[0]].last['To'])
+            changed_res = ''
           end
+          hash[feature[0]].last['diff'] = [original_res, chenged_res]
         end
       end
-      @data['FT'] = table
+    rescue
+      raise "Invalid FT Lines(#{$!}) in #{entry_id}:, \n'#{self.get('FT')}'\n"
     end
 
-    if feature_name
-      @data['FT'][feature_name]
-    else
-      @data['FT']
-    end
+    @data['FT'] = hash
   end
 
 
+
   # returns a Hash of conteins in the SQ lines.
   # * Bio::SPTRL#sq  -> hsh
   #
   # returns a value of a key given in the SQ lines.
   # * Bio::SPTRL#sq(key)  -> int or str
-  # * Keys: ['MW', 'mw', 'molecular', 'weight', 'aalen', 'len', 'length', 'CRC64']
+  # * Keys: ['MW', 'mw', 'molecular', 'weight', 'aalen', 'len', 'length', 
+  #          'CRC64']
   #
   # === SQ Line; sequence header (1/entry)
   #    SQ   SEQUENCE   233 AA;  25630 MW;  146A1B48A1475C86 CRC64;
@@ -759,84 +1145,6 @@ end # class SPTR
 end # module Bio
 
 
-if __FILE__ == $0
-  # Usage: ruby __FILE__ uniprot_sprot.dat 
-  # Usage: ruby __FILE__ uniprot_sprot.dat | egrep '^RuntimeError'
-
-  begin
-    require 'pp'
-    alias pp p
-  rescue LoadError
-  end
-
-  def cmd(cmd, tag = nil, ent = $ent)
-    puts " ==> #{cmd} "
-    puts Bio::SPTR.new(ent).get(tag) if tag
-    begin
-      p eval(cmd)
-    rescue RuntimeError
-      puts "RuntimeError(#{Bio::SPTR.new($ent).entry_id})}: #{$!} "
-    end
-    puts
-  end
-
-
-  while $ent = $<.gets(Bio::SPTR::RS)
-    
-    cmd "Bio::SPTR.new($ent).entry_id"
-
-    cmd "Bio::SPTR.new($ent).id_line", 'ID'
-    cmd "Bio::SPTR.new($ent).entry"
-    cmd "Bio::SPTR.new($ent).entry_name"
-    cmd "Bio::SPTR.new($ent).molecule"
-    cmd "Bio::SPTR.new($ent).sequence_length"
-
-    cmd "Bio::SPTR.new($ent).ac", 'AC'
-    cmd "Bio::SPTR.new($ent).accession"
-
-
-    cmd "Bio::SPTR.new($ent).gn", 'GN'
-    cmd "Bio::SPTR.new($ent).gene_name"
-    cmd "Bio::SPTR.new($ent).gene_names"
-
-    cmd "Bio::SPTR.new($ent).dt", "DT"
-    ['created','annotation','sequence'].each do |key|
-      cmd "Bio::SPTR.new($ent).dt('#{key}')"
-    end
-
-    cmd "Bio::SPTR.new($ent).de", 'DE'
-    cmd "Bio::SPTR.new($ent).definition"
-    cmd "Bio::SPTR.new($ent).protein_name"
-    cmd "Bio::SPTR.new($ent).synonyms"
-
-    cmd "Bio::SPTR.new($ent).kw", 'KW'
-
-    cmd "Bio::SPTR.new($ent).os", 'OS'
-
-    cmd "Bio::SPTR.new($ent).oc", 'OC'
-
-    cmd "Bio::SPTR.new($ent).og", 'OG'
-
-    cmd "Bio::SPTR.new($ent).ox", 'OX'
-
-    cmd "Bio::SPTR.new($ent).ref", 'R'
-
-    cmd "Bio::SPTR.new($ent).cc", 'CC'
-    cmd "Bio::SPTR.new($ent).cc('ALTERNATIVE PRODUCTS')"
-    cmd "Bio::SPTR.new($ent).cc('DATABASE')"
-    cmd "Bio::SPTR.new($ent).cc('MASS SPECTOMETRY')"
-
-    cmd "Bio::SPTR.new($ent).dr", 'DR'
-
-    cmd "Bio::SPTR.new($ent).ft", 'FT'
-    cmd "Bio::SPTR.new($ent).ft['DOMAIN']"
-
-    cmd "Bio::SPTR.new($ent).sq", "SQ"
-    cmd "Bio::SPTR.new($ent).seq"
-  end
-
-end
-
 
 =begin
 
@@ -955,6 +1263,7 @@ Class for a entry in the SWISS-PROT/TrEMBL database.
   # OG - organelle                    (0 or 1 per entry; optional)
   # OC - organism classification      (>=1 per entry)
   # OX - organism taxonomy x-ref      (>=1 per entry)
+  # OH - Organism Host
   # RN - reference number             (>=1 per entry)
   # RP - reference positions          (>=1 per entry)
   # RC - reference comment(s)         (>=0 per entry; optional)
@@ -962,6 +1271,7 @@ Class for a entry in the SWISS-PROT/TrEMBL database.
   # RA - reference author(s)          (>=1 per entry)
   # RT - reference title              (>=0 per entry; optional)
   # RL - reference location           (>=1 per entry)
+  # RG - reference group(s)
   # CC - comments or notes            (>=0 per entry; optional)
   # DR - database cross-references    (>=0 per entry; optional)
   # KW - keywords                     (>=1 per entry)