wwood-bioruby 1.2.11

data/lib/bio/io/biosql/ontology.rb

@@ -0,0 +1,10 @@
+
+ module Bio
+    class SQL 
+		    class Ontology < DummyBase
+		      has_many :terms, :class_name => "Term"
+		      has_many :term_paths, :class_name => "TermPath"
+		      has_many :term_relationships, :class_name => "TermRelationship"
+		    end		
+		end #SQL
+end #Bio

data/lib/bio/io/biosql/reference.rb

@@ -0,0 +1,9 @@
+
+ module Bio
+    class SQL 
+		    class Reference < DummyBase  
+		      belongs_to :dbxref, :class_name => "Dbxref"
+		      has_many :bioentry_references, :class_name=>"BioentryRefernce"
+		    end		
+		end #SQL
+end #Bio

data/lib/bio/io/biosql/seqfeature.rb

@@ -0,0 +1,32 @@
+
+module Bio
+  class SQL 
+    class Seqfeature <DummyBase  
+      set_sequence_name "seqfeature_pk_seq"
+      belongs_to :bioentry
+      #, :class_name => "Bioentry"
+      belongs_to :type_term, :class_name => "Term", :foreign_key => "type_term_id"
+      belongs_to :source_term, :class_name => "Term", :foreign_key =>"source_term_id"
+      has_many :seqfeature_dbxrefs, :class_name => "SeqfeatureDbxref", :foreign_key => "seqfeature_id"
+      has_many :seqfeature_qualifier_values, :order=>'rank', :foreign_key => "seqfeature_id"
+      #, :class_name => "SeqfeatureQualifierValue"
+      has_many :locations, :class_name => "Location", :order=>'rank'
+      has_many :object_seqfeature_paths, :class_name => "SeqfeaturePath", :foreign_key => "object_seqfeature_id"
+      has_many :subject_seqfeature_paths, :class_name => "SeqfeaturePath", :foreign_key => "subject_seqfeature_id"
+      has_many :object_seqfeature_relationships, :class_name => "SeqfeatureRelationship", :foreign_key => "object_seqfeature_id"
+      has_many :subject_seqfeature_relationships, :class_name => "SeqfeatureRelationship", :foreign_key => "subject_seqfeature_id"
+
+      #get the subsequence described by the locations objects
+      def sequence
+        return self.locations.inject(Bio::Sequence::NA.new("")){|seq, location| seq<<location.sequence}
+    end
+    
+      #translate the subsequences represented by the feature and its locations
+      #not considering the qualifiers 
+      #Return a Bio::Sequence::AA object
+      def translate(*args)
+        self.sequence.translate(*args)
+      end
+      end		
+    end #SQL
+  end #Bio

data/lib/bio/io/biosql/seqfeature_dbxref.rb

@@ -0,0 +1,11 @@
+
+ module Bio
+    class SQL 
+		    class SeqfeatureDbxref < DummyBase
+		      set_primary_keys :seqfeature_id, :dbxref_id
+#delete		      set_sequence_name nil
+		      belongs_to :seqfeature, :class_name => "Seqfeature", :foreign_key => "seqfeature_id"
+		      belongs_to :dbxref, :class_name => "Dbxref", :foreign_key => "dbxref_id"
+		    end		
+		end #SQL
+end #Bio

data/lib/bio/io/biosql/seqfeature_path.rb

@@ -0,0 +1,11 @@
+ module Bio
+    class SQL 
+			   class SeqfeaturePath < DummyBase
+			      set_primary_keys :object_seqfeature_id, :subject_seqfeature_id, :term_id
+			      set_sequence_name nil
+			      belongs_to :object_seqfeature, :class_name => "Seqfeature", :foreign_key => "object_seqfeature_id"
+			      belongs_to :subject_seqfeature, :class_name => "Seqfeature", :foreign_key => "subject_seqfeature_id"
+            belongs_to :term, :class_name => "Term"
+			    end		
+		end #SQL
+end #Bio

data/lib/bio/io/biosql/seqfeature_qualifier_value.rb

@@ -0,0 +1,20 @@
+
+module Bio
+  class SQL 
+    class SeqfeatureQualifierValue < DummyBase
+      set_primary_keys  :seqfeature_id, :term_id, :rank
+      set_sequence_name nil
+      belongs_to :seqfeature
+      belongs_to :term, :class_name => "Term"
+      
+      def self.find_cluster(query)
+        term_note= Term.find_by_name('note')
+        find(:all, :conditions =>["value like ? and term_id = ?", "cl:#{query}", term_note])
+      end
+      def self.find_cluster_info(query)
+        term_note= Term.find_by_name('note')
+        find(:all, :conditions =>["value like ? and term_id = ?", "cli:#{query}", term_note])
+      end
+    end		
+  end #SQL
+end #Bio

data/lib/bio/io/biosql/seqfeature_relationship.rb

@@ -0,0 +1,11 @@
+
+ module Bio
+    class SQL 
+			    class SeqfeatureRelationship <DummyBase
+			      set_sequence_name "seqfeatue_relationship_pk_seq"
+			      belongs_to :term, :class_name => "Term"
+			      belongs_to :object_seqfeature, :class_name => "Seqfeature"
+			      belongs_to :subject_seqfeature, :class_name => "Seqfeature"
+			    end		
+		end #SQL
+end #Bio

data/lib/bio/io/biosql/taxon.rb

@@ -0,0 +1,12 @@
+
+ module Bio
+    class SQL 
+			    class Taxon < DummyBase
+			      set_sequence_name "taxon_pk_seq"
+			      has_many :taxon_names, :class_name => "TaxonName"
+		              has_one :taxon_scientific_name, :class_name => "TaxonName", :conditions=>"name_class = 'scientific name'"
+		              has_one :taxon_genbank_common_name, :class_name => "TaxonName", :conditions=>"name_class = 'genbank common name'"
+			      has_one :bioentry, :class_name => "Bioentry"
+			    end		
+		end #SQL
+end #Bio

data/lib/bio/io/biosql/taxon_name.rb

@@ -0,0 +1,9 @@
+
+ module Bio
+    class SQL 
+			    class TaxonName < DummyBase
+			      set_primary_keys :taxon_id, :name, :name_class
+			      belongs_to :taxon, :class_name => "Taxon"      
+			    end		
+		end #SQL
+end #Bio

data/lib/bio/io/biosql/term.rb

@@ -0,0 +1,27 @@
+
+ module Bio
+    class SQL 
+			    class Term < DummyBase
+			      belongs_to :ontology, :class_name => "Ontology"
+			      has_many :seqfeature_qualifier_values, :class_name => "SeqfeatureQualifierValue"
+			      has_many :dbxref_qualifier_values, :class_name => "DbxrefQualifierValue"
+            has_many :bioentry_qualifer_values, :class_name => "BioentryQualifierValue"
+            has_many :bioentries, :through=>:bioentry_qualifier_values
+			      has_many :locations, :class_name => "Location"
+			      has_many :seqfeature_relationships, :class_name => "SeqfeatureRelationship"
+			      has_many :term_dbxrefs, :class_name => "TermDbxref"
+			      has_many :term_relationship_terms, :class_name => "TermRelationshipTerm"
+			      has_many :term_synonyms, :class_name => "TermSynonym"
+			      has_many :location_qualifier_values, :class_name => "LocationQualifierValue"
+			      has_many :seqfeature_types, :class_name => "Seqfeature", :foreign_key => "type_term_id"			      
+			      has_many :seqfeature_sources, :class_name => "Seqfeature", :foreign_key => "source_term_id"			      
+			      has_many :term_path_subjects, :class_name => "TermPath", :foreign_key => "subject_term_id"
+			      has_many :term_path_predicates, :class_name => "TermPath", :foreign_key => "predicate_term_id"
+			      has_many :term_path_objects, :class_name => "TermPath", :foreign_key => "object_term_id"			      
+			      has_many :term_relationship_subjects, :class_name => "TermRelationship", :foreign_key =>"subject_term_id"
+			      has_many :term_relationship_predicates, :class_name => "TermRelationship", :foreign_key =>"predicate_term_id"
+			      has_many :term_relationship_objects, :class_name => "TermRelationship", :foreign_key =>"object_term_id"
+            has_many :seqfeature_paths, :class_name => "SeqfeaturePath"
+			    end		
+		end #SQL
+end #Bio

data/lib/bio/io/biosql/term_dbxref.rb

@@ -0,0 +1,11 @@
+
+ module Bio
+    class SQL 
+			    class TermDbxref < DummyBase
+			      set_primary_key nil #term_id, dbxref_id
+#delete			      set_sequence_name nil
+			      belongs_to :term, :class_name => "Term"
+			      belongs_to :dbxref, :class_name => "Dbxref"
+			    end		
+		end #SQL
+end #Bio

data/lib/bio/io/biosql/term_path.rb

@@ -0,0 +1,12 @@
+
+ module Bio
+    class SQL 
+			    class TermPath < DummyBase
+			      set_sequence_name "term_path_pk_seq"
+			      belongs_to :ontology, :class_name => "Ontology"
+			      belongs_to :subject_term, :class_name => "Term"
+			      belongs_to :object_term, :class_name => "Term"
+			      belongs_to :predicate_term, :class_name => "Term"
+			    end		
+		end #SQL
+end #Bio

data/lib/bio/io/biosql/term_relationship.rb

@@ -0,0 +1,13 @@
+
+ module Bio
+    class SQL 
+			    class TermRelationship < DummyBase
+			      set_sequence_name "term_relationship_pk_seq"
+			      belongs_to :ontology, :class_name => "Ontology"
+			      belongs_to :subject_term, :class_name => "Term"
+			      belongs_to :predicate_term, :class_name => "Term"
+			      belongs_to :object_term, :class_name => "Term"
+			      has_one :term_relationship_term, :class_name => "TermRelationshipTerm"
+			    end		
+		end #SQL
+end #Bio

data/lib/bio/io/biosql/term_relationship_term.rb

@@ -0,0 +1,11 @@
+
+ module Bio
+    class SQL 
+			    class TermRelationshipTerm < DummyBase
+#delete			      set_sequence_name nil
+			      set_primary_key :term_relationship_id
+			      belongs_to :term_relationship, :class_name => "TermRelationship"
+			      belongs_to :term, :class_name => "Term"
+			    end		
+		end #SQL
+end #Bio

data/lib/bio/io/biosql/term_synonym.rb

@@ -0,0 +1,10 @@
+
+ module Bio
+    class SQL 
+			    class TermSynonym < DummyBase
+#delete			      set_sequence_name nil
+			      set_primary_key nil
+			      belongs_to :term, :class_name => "Term"
+			    end		
+		end #SQL
+end #Bio

data/lib/bio/io/das.rb

@@ -0,0 +1,461 @@
+#
+# = bio/io/das.rb - BioDAS access module
+#
+# Copyright::	Copyright (C) 2003, 2004, 2007
+#		Shuichi Kawashima <shuichi@hgc.jp>,
+#		Toshiaki Katayama <k@bioruby.org>
+# License::	The Ruby License
+#
+# $Id:$
+#
+#--
+# == TODO
+#
+#  link, stylesheet
+#
+#++
+#
+
+begin
+  require 'rexml/document'
+rescue LoadError
+end
+require 'bio/command'
+require 'bio/sequence'
+
+
+module Bio
+
+class DAS
+
+  # Specify DAS server to connect
+  def initialize(url = 'http://www.wormbase.org:80/db/')
+    @server = url.chomp('/')
+  end
+
+  def dna(dsn, entry_point, start, stop)
+    seg = Bio::DAS::SEGMENT.region(entry_point, start, stop)
+    self.get_dna(dsn, seg).first.sequence
+  end
+
+  def features(dsn, entry_point, start, stop)
+    seg = Bio::DAS::SEGMENT.region(entry_point, start, stop)
+    self.get_features(dsn, seg)
+  end
+
+
+  # Returns an Array of Bio::DAS::DSN
+  def get_dsn
+    ary = []
+    result = Bio::Command.post_form("#{@server}/das/dsn")
+    doc = REXML::Document.new(result.body)
+    doc.elements.each('/descendant::DSN') do |e|
+      dsn = DSN.new
+      e.elements.each do |e|
+        case e.name
+        when 'SOURCE'
+          dsn.source = e.text
+          dsn.source_id = e.attributes['id']
+          dsn.source_version = e.attributes['version']
+        when 'MAPMASTER'
+          dsn.mapmaster = e.text
+        when 'DESCRIPTION'
+          dsn.description = e.text
+          dsn.description_href = e.attributes['href']
+        end
+      end
+      ary << dsn
+    end
+    ary
+  end
+
+  # Returns Bio::DAS::ENTRY_POINT.
+  # The 'dsn' can be a String or a Bio::DAS::DSN object.
+  def get_entry_points(dsn)
+    entry_point = ENTRY_POINT.new
+    if dsn.instance_of?(Bio::DAS::DSN)
+      src = dsn.source 
+    else
+      src = dsn
+    end
+    result = Bio::Command.post_form("#{@server}/das/#{src}/entry_points")
+    doc = REXML::Document.new(result.body)
+    doc.elements.each('/descendant::ENTRY_POINTS') do |e|
+      entry_point.href = e.attributes['href']
+      entry_point.version = e.attributes['version']
+      e.elements.each do |e|
+        segment = SEGMENT.new
+        segment.entry_id = e.attributes['id']
+        segment.start = e.attributes['start']
+        segment.stop = e.attributes['stop'] || e.attributes['size']
+        segment.orientation = e.attributes['orientation']
+        segment.subparts = e.attributes['subparts']
+        segment.description = e.text
+        entry_point.segments << segment
+      end
+    end
+    entry_point
+  end
+
+  # Returns an Array of Bio::DAS::DNA.
+  # The 'dsn' can be a String or a Bio::DAS::DSN object.
+  # The 'segments' can be a Bio::DAS::SEGMENT object or an Array of
+  # Bio::DAS::SEGMENT
+  def get_dna(dsn, segments)
+    ary = []
+
+    dsn = dsn.source if dsn.instance_of?(DSN)
+    segments = [segments] if segments.instance_of?(SEGMENT)
+
+    opts = []
+    segments.each do |s|
+      opts << "segment=#{s.entry_id}:#{s.start},#{s.stop}"
+    end
+
+    result = Bio::Command.post_form("#{@server}/das/#{dsn}/dna", opts)
+    doc = REXML::Document.new(result.body)
+    doc.elements.each('/descendant::SEQUENCE') do |e|
+      sequence = DNA.new
+      sequence.entry_id = e.attributes['id']
+      sequence.start = e.attributes['start']
+      sequence.stop = e.attributes['stop']
+      sequence.version = e.attributes['version']
+      e.elements.each do |e|
+        sequence.sequence = Bio::Sequence::NA.new(e.text)
+        sequence.length = e.attributes['length'].to_i
+      end
+      ary << sequence
+    end
+    ary
+  end
+
+  # Returns an Array of Bio::DAS::SEQUENCE.
+  # The 'dsn' can be a String or a Bio::DAS::DSN object.
+  # The 'segments' can be a Bio::DAS::SEGMENT object or an Array of
+  # Bio::DAS::SEGMENT
+  def get_sequence(dsn, segments)
+    ary = []
+
+    dsn = dsn.source if dsn.instance_of?(DSN)
+    segments = [segments] if segments.instance_of?(SEGMENT)
+
+    opts = []
+    segments.each do |s|
+      opts << "segment=#{s.entry_id}:#{s.start},#{s.stop}"
+    end
+
+    result = Bio::Command.post_form("#{@server}/das/#{dsn}/sequence", opts)
+    doc = REXML::Document.new(result.body)
+    doc.elements.each('/descendant::SEQUENCE') do |e|
+      sequence = SEQUENCE.new
+      sequence.entry_id = e.attributes['id']
+      sequence.start = e.attributes['start']
+      sequence.stop = e.attributes['stop']
+      sequence.moltype = e.attributes['moltype']
+      sequence.version = e.attributes['version']
+      case sequence.moltype
+      when /dna|rna/i		# 'DNA', 'ssRNA', 'dsRNA'
+        sequence.sequence = Bio::Sequence::NA.new(e.text)
+      when /protein/i		# 'Protein
+        sequence.sequence = Bio::Sequence::AA.new(e.text)
+      else
+        sequence.sequence = e.text
+      end
+      ary << sequence
+    end
+    ary
+  end
+
+  # Returns a Bio::DAS::TYPES object.
+  # The 'dsn' can be a String or a Bio::DAS::DSN object.
+  # The 'segments' is optional and can be a Bio::DAS::SEGMENT object or
+  # an Array of Bio::DAS::SEGMENT
+  def get_types(dsn, segments = [])	# argument 'type' is deprecated
+    types = TYPES.new
+
+    dsn = dsn.source if dsn.instance_of?(DSN)
+    segments = [segments] if segments.instance_of?(SEGMENT)
+
+    opts = []
+    segments.each do |s|
+      opts << "segment=#{s.entry_id}:#{s.start},#{s.stop}"
+    end
+
+    result = Bio::Command.post_form("#{@server}/das/#{dsn}/types", opts)
+    doc = REXML::Document.new(result.body)
+    doc.elements.each('/descendant::GFF') do |e|
+      types.version = e.attributes['version']
+      types.href = e.attributes['href']
+      e.elements.each do |e|
+        segment = SEGMENT.new
+        segment.entry_id = e.attributes['id']
+        segment.start = e.attributes['start']
+        segment.stop = e.attributes['stop']
+        segment.version = e.attributes['version']
+        segment.label = e.attributes['label']
+        e.elements.each do |e|
+          t = TYPE.new
+          t.entry_id = e.attributes['id']
+          t.method = e.attributes['method']
+          t.category = e.attributes['category']
+          t.count = e.text.to_i
+          segment.types << t
+        end
+        types.segments << segment
+      end
+    end
+    types
+  end
+
+  # Returns a Bio::DAS::GFF object.
+  # The 'dsn' can be a String or a Bio::DAS::DSN object.
+  # The 'segments' is optional and can be a Bio::DAS::SEGMENT object or
+  # an Array of Bio::DAS::SEGMENT
+  def get_features(dsn, segments = [], categorize = false, feature_ids = [], group_ids = [])
+    # arguments 'type' and 'category' are deprecated
+    gff = GFF.new
+
+    dsn = dsn.source if dsn.instance_of?(DSN)
+    segments = [segments] if segments.instance_of?(SEGMENT)
+
+    opts = []
+    segments.each do |s|
+      opts << "segment=#{s.entry_id}:#{s.start},#{s.stop}"
+    end
+    if categorize
+      opts << "categorize=yes"	# default is 'no'
+    end
+    feature_ids.each do |fid|
+      opts << "feature_id=#{fid}"
+    end
+    group_ids.each do |gid|
+      opts << "group_id=#{gid}"
+    end
+
+    result = Bio::Command.post_form("#{@server}/das/#{dsn}/features", opts)
+    doc = REXML::Document.new(result.body)
+    doc.elements.each('/descendant::GFF') do |e|
+      gff.version = e.attributes['version']
+      gff.href = e.attributes['href']
+      e.elements.each('SEGMENT') do |e|
+        segment = SEGMENT.new
+        segment.entry_id = e.attributes['id']
+        segment.start = e.attributes['start']
+        segment.stop = e.attributes['stop']
+        segment.version = e.attributes['version']
+        segment.label = e.attributes['label']
+        e.elements.each do |e|
+          feature = FEATURE.new
+          feature.entry_id = e.attributes['id']
+          feature.label = e.attributes['label']
+          e.elements.each do |e|
+            case e.name
+            when 'TYPE'
+              type = TYPE.new
+              type.entry_id = e.attributes['id']
+              type.category = e.attributes['category']
+              type.reference = e.attributes['referrence']
+              type.label = e.text
+              feature.types << type
+            when 'METHOD'
+              feature.method_id = e.attributes['id']
+              feature.method = e.text
+            when 'START'
+              feature.start = e.text
+            when 'STOP', 'END'
+              feature.stop = e.text
+            when 'SCORE'
+              feature.score = e.text
+            when 'ORIENTATION'
+              feature.orientation = e.text
+            when 'PHASE'
+              feature.phase = e.text
+            when 'NOTE'
+              feature.notes << e.text
+            when 'LINK'
+              link = LINK.new
+              link.href = e.attributes['href']
+              link.text = e.text
+              feature.links << link
+            when 'TARGET'
+              target = TARGET.new
+              target.entry_id = e.attributes['id']
+              target.start = e.attributes['start']
+              target.stop = e.attributes['stop']
+              target.name = e.text
+              feature.targets << target
+            when 'GROUP'
+              group = GROUP.new
+              group.entry_id = e.attributes['id']
+              group.label = e.attributes['label']
+              group.type = e.attributes['type']
+              e.elements.each do |e|
+                case e.name
+                when 'NOTE'		# in GROUP
+                  group.notes << e.text
+                when 'LINK'		# in GROUP
+                  link = LINK.new
+                  link.href = e.attributes['href']
+                  link.text = e.text
+                  group.links << link
+                when 'TARGET'		# in GROUP
+                  target = TARGET.new
+                  target.entry_id = e.attributes['id']
+                  target.start = e.attributes['start']
+                  target.stop = e.attributes['stop']
+                  target.name = e.text
+                  group.targets << target
+                end
+              end
+              feature.groups << group
+            end
+          end
+          segment.features << feature
+        end
+        gff.segments << segment
+      end
+    end
+    gff
+  end
+
+
+  class DSN
+    attr_accessor :source, :source_id, :source_version,
+      :mapmaster, :description, :description_href
+  end
+
+  class ENTRY_POINT
+    def initialize
+      @segments = Array.new
+    end
+    attr_reader :segments
+    attr_accessor :href, :version
+
+    def each
+      @segments.each do |x|
+        yield x
+      end
+    end
+  end
+
+  class SEGMENT
+    def self.region(entry_id, start, stop)
+      segment = self.new
+      segment.entry_id = entry_id
+      segment.start = start
+      segment.stop = stop
+      return segment
+    end
+
+    def initialize
+      @features = Array.new		# for FEATURE
+      @types = Array.new		# for TYPE
+    end
+    attr_accessor :entry_id, :start, :stop, :orientation, :description,
+      :subparts,			# optional
+      :features, :version, :label,	# for FEATURE
+      :types				# for TYPE
+  end
+
+  class DNA
+    attr_accessor :entry_id, :start, :stop, :version, :sequence, :length
+  end
+
+  class SEQUENCE
+    attr_accessor :entry_id, :start, :stop, :moltype, :version, :sequence
+  end
+
+  class TYPES < ENTRY_POINT; end
+
+  class TYPE
+    attr_accessor :entry_id, :method, :category, :count,
+      :reference, :label	# for FEATURE
+  end
+
+  class GFF
+    def initialize
+      @segments = Array.new
+    end
+    attr_reader :segments
+    attr_accessor :version, :href
+  end
+
+  class FEATURE
+    def initialize
+      @notes = Array.new
+      @links = Array.new
+      @types = Array.new
+      @targets = Array.new
+      @groups = Array.new
+    end
+    attr_accessor :entry_id, :label,
+      :method_id, :method, :start, :stop, :score, :orientation, :phase
+    attr_reader :notes, :links, :types, :targets, :groups
+  end
+
+  class LINK
+    attr_accessor :href, :text
+  end
+
+  class TARGET
+    attr_accessor :entry_id, :start, :stop, :name
+  end
+
+  class GROUP
+    def initialize
+      @notes = Array.new
+      @links = Array.new
+      @targets = Array.new
+    end
+    attr_accessor :entry_id, :label, :type
+    attr_reader :notes, :links, :targets
+  end
+
+end
+
+end # module Bio
+
+
+if __FILE__ == $0
+
+# begin
+#   require 'pp'
+#   alias p pp
+# rescue LoadError
+# end
+
+  puts "### WormBase"
+  wormbase = Bio::DAS.new('http://www.wormbase.org/db/')
+
+  puts ">>> test get_dsn"
+  p wormbase.get_dsn
+
+  puts ">>> create segment obj Bio::DAS::SEGMENT.region('I', 1, 1000)"
+  seg = Bio::DAS::SEGMENT.region('I', 1, 1000)
+  p seg
+
+  puts ">>> test get_dna"
+  p wormbase.get_dna('elegans', seg)
+
+  puts "### test get_features"
+  p wormbase.get_features('elegans', seg)
+
+  puts "### KEGG DAS"
+  kegg_das = Bio::DAS.new("http://das.hgc.jp/cgi-bin/")
+
+  dsn_list = kegg_das.get_dsn
+  org_list = dsn_list.collect {|x| x.source}
+
+  puts ">>> dsn : entry_points"
+  org_list.each do |org|
+    print "#{org} : "
+    list = kegg_das.get_entry_points(org)
+    list.segments.each do |seg|
+      print " #{seg.entry_id}"
+    end
+    puts
+  end
+
+end
+
+