bio-biosql 0.0.0

data/lib/bio/io/biosql/ar-biosql.rb

@@ -0,0 +1,257 @@
+module Bio
+  class SQL
+    class Biodatabase < DummyBase
+      has_many :bioentries, :class_name =>"Bioentry", :foreign_key => "biodatabase_id"
+      validates_uniqueness_of :name
+    end
+    class BioentryDbxref < DummyBase
+      #delete				set_sequence_name nil
+      set_primary_key nil #bioentry_id,dbxref_id
+      belongs_to :bioentry, :class_name => "Bioentry"
+      belongs_to :dbxref, :class_name => "Dbxref"
+    end
+
+    class BioentryPath < DummyBase
+      set_primary_key nil
+      #delete				set_sequence_name nil
+      belongs_to :term, :class_name => "Term"
+      #da sistemare per poter procedere.
+      belongs_to :object_bioentry, :class_name=>"Bioentry"
+      belongs_to :subject_bioentry, :class_name=>"Bioentry"
+    end #BioentryPath
+
+    class BioentryQualifierValue < DummyBase
+      #NOTE: added rank to primary_keys, now it's finished.
+      set_primary_keys :bioentry_id, :term_id, :rank
+      belongs_to :bioentry, :class_name => "Bioentry"
+      belongs_to :term, :class_name => "Term"
+    end #BioentryQualifierValue
+  
+    class Bioentry < DummyBase
+      belongs_to :biodatabase, :class_name => "Biodatabase"
+      belongs_to :taxon, :class_name => "Taxon"
+      has_one :biosequence
+      #, :class_name => "Biosequence", :foreign_key => "bioentry_id"
+      has_many :comments, :class_name =>"Comment", :order =>'rank'
+      has_many :seqfeatures, :class_name => "Seqfeature", :order=>'rank'
+      has_many :bioentry_references, :class_name=>"BioentryReference" #, :foreign_key => "bioentry_id"
+      has_many :bioentry_dbxrefs, :class_name => "BioentryDbxref"
+      has_many :object_bioentry_relationships, :class_name=>"BioentryRelationship", :foreign_key=>"object_bioentry_id" #non mi convince molto credo non funzioni nel modo corretto
+      has_many :subject_bioentry_relationships, :class_name=>"BioentryRelationship", :foreign_key=>"subject_bioentry_id" #non mi convince molto credo non funzioni nel modo corretto
+      has_many :object_bioentry_paths, :class_name=>"BioentryPath", :foreign_key=>"object_bioentry_id" #non mi convince molto credo non funzioni nel modo corretto
+      has_many :subject_bioentry_paths, :class_name=>"BioentryPath", :foreign_key=>"subject_bioentry_id" #non mi convince molto credo non funzioni nel modo corretto
+
+      has_many :cdsfeatures, :class_name=>"Seqfeature", :foreign_key =>"bioentry_id", :conditions=>["term.name='CDS'"], :include=>"type_term"
+      has_many :references, :through=>:bioentry_references, :class_name => "Reference"
+      has_many :terms, :through=>:bioentry_qualifier_values, :class_name => "Term"
+      #NOTE: added order_by for multiple hit and manage ranks correctly
+      has_many :bioentry_qualifier_values, :order=>"bioentry_id,term_id,rank", :class_name => "BioentryQualifierValue"
+        
+      #per la creazione richiesti:
+      #name, accession, version
+      #				validates_uniqueness_of :accession, :scope=>[:biodatabase_id]
+      #				validates_uniqueness_of :name, :scope=>[:biodatabase_id]
+			#	validates_uniqueness_of :identifier, :scope=>[:biodatabase_id]
+				
+    end
+    class BioentryReference < DummyBase
+      set_primary_keys :bioentry_id, :reference_id, :rank
+      belongs_to :bioentry, :class_name => "Bioentry"
+      belongs_to :reference , :class_name => "Reference"
+    end
+    class BioentryRelationship < DummyBase
+      #delete				set_primary_key "bioentry_relationship_id"
+      set_sequence_name "bieontry_relationship_pk_seq"
+      belongs_to :object_bioentry, :class_name => "Bioentry"
+      belongs_to :subject_bioentry, :class_name => "Bioentry"
+      belongs_to :term
+    end
+    class Biosequence < DummyBase
+      set_primary_keys :bioentry_id, :version
+      #delete				set_sequence_name "biosequence_pk_seq"
+      belongs_to :bioentry, :foreign_key=>"bioentry_id"
+      #has_one :bioentry
+      #, :class_name => "Bioentry"
+    end
+    class Comment < DummyBase
+      belongs_to :bioentry, :class_name => "Bioentry"
+    end
+    class DbxrefQualifierValue < DummyBase
+      #think to use composite primary key
+      set_primary_key nil #dbxref_id, term_id, rank
+      #delete			      set_sequence_name nil
+      belongs_to :dbxref, :class_name => "Dbxref"
+      belongs_to :term, :class_name => "Term"
+    end
+    class Dbxref < DummyBase
+      #set_sequence_name "dbxref_pk_seq"
+      has_many :dbxref_qualifier_values, :class_name => "DbxrefQualifierValue"
+      has_many :locations, :class_name => "Location"
+      has_many :references, :class_name=>"Reference"
+      has_many :term_dbxrefs, :class_name => "TermDbxref"
+      has_many :bioentry_dbxrefs, :class_name => "BioentryDbxref"
+      #TODO: check is with bioentry there is an has_and_belongs_to_many relationship has specified in schema overview.
+    end
+    class LocationQualifierValue <  DummyBase
+      set_primary_key nil #location_id, term_id
+      #delete			      set_sequence_name nil
+      belongs_to :location, :class_name => "Location"
+      belongs_to :term, :class_name => "Term"
+    end
+    class Location < DummyBase
+      #set_sequence_name "location_pk_seq"
+      belongs_to :seqfeature, :class_name => "Seqfeature"
+      belongs_to :dbxref, :class_name => "Dbxref"
+      belongs_to :term, :class_name => "Term"
+      has_many :location_qualifier_values, :class_name => "LocationQualifierValue"
+      
+      def to_s
+        if strand==-1
+          str="complement("+start_pos.to_s+".."+end_pos.to_s+")"
+        else
+          str=start_pos.to_s+".."+end_pos.to_s
+        end
+        return str    
+      end
+      
+      def sequence
+        seq=""
+        unless self.seqfeature.bioentry.biosequence.seq.nil?
+          seq=Bio::Sequence::NA.new(self.seqfeature.bioentry.biosequence.seq[start_pos-1..end_pos-1])
+          seq.reverse_complement! if strand==-1
+        end
+        return seq        
+      end
+      
+      
+      
+    end
+    class Ontology < DummyBase
+      has_many :terms, :class_name => "Term"
+      has_many :term_paths, :class_name => "TermPath"
+      has_many :term_relationships, :class_name => "TermRelationship"
+    end
+    class Reference < DummyBase
+      belongs_to :dbxref, :class_name => "Dbxref"
+      has_many :bioentry_references, :class_name=>"BioentryReference"
+      has_many :bioentries, :through=>:bioentry_references
+    end
+    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
+    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
+    class SeqfeatureQualifierValue < DummyBase
+      set_primary_keys  :seqfeature_id, :term_id, :rank
+      set_sequence_name nil
+      belongs_to :seqfeature
+      belongs_to :term, :class_name => "Term"
+    end		
+    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
+    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
+    class TaxonName < DummyBase
+      set_primary_keys :taxon_id, :name, :name_class
+      belongs_to :taxon, :class_name => "Taxon"
+    end
+    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
+    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
+    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
+    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
+    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
+    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
+    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/biosql/biosql.rb

@@ -0,0 +1,39 @@
+#require 'dm-ar-finders'
+#require 'dm-core'
+require 'erb'
+require 'composite_primary_keys'
+
+module Bio
+ class SQL
+    class DummyBase < ActiveRecord::Base
+      #NOTE: Using postgresql, not setting sequence name, system will discover the name by default.
+      #NOTE: this class will not establish the connection automatically
+      self.abstract_class = true
+      self.pluralize_table_names = false
+      #prepend table name to the usual id, avoid to specify primary id for every table
+      self.primary_key_prefix_type = :table_name_with_underscore
+      #biosql_configurations=YAML::load(ERB.new(IO.read(File.join(File.dirname(__FILE__),'./config', 'database.yml'))).result)
+      #self.configurations=biosql_configurations
+      #self.establish_connection "development"
+    end #DummyBase
+
+    require 'bio/io/biosql/ar-biosql'
+    
+  #  #no check is made
+  def self.establish_connection(configurations, env)
+    #  #configurations is an hash similar what YAML returns.
+
+     #configurations.assert_valid_keys('development', 'production','test')
+     #configurations[env].assert_valid_keys('hostname','database','adapter','username','password')
+     DummyBase.configurations = configurations
+    connection = DummyBase.establish_connection "#{env}"
+    #Init of basis terms and ontologies
+    Ontology.first(:conditions => ["name = ?", 'Annotation Tags']) || Ontology.create({:name => 'Annotation Tags'})
+    Ontology.first(:conditions => ["name = ?", 'SeqFeature Keys']) || Ontology.create({:name => 'SeqFeature Keys'})
+    Ontology.first(:conditions => ["name = ?", 'SeqFeature Sources']) ||Ontology.create({:name => 'SeqFeature Sources'})
+    Term.first(:conditions => ["name = ?", 'EMBLGenBankSwit']) || Term.create({:name => 'EMBLGenBankSwit', :ontology => Ontology.first(:conditions => ["name = ?", 'SeqFeature Sources'])})
+    connection 
+  end #establish_connection
+  
+  end #SQL
+end #Bio

data/lib/bio/io/biosql/config/database.yml

@@ -0,0 +1,21 @@
+#This is the database configuration specific for BioSQL
+#User can configure it's db here
+
+development:
+  adapter: jdbcmysql
+  database: bioseq
+  username: febo
+  password:
+  hostname: localhost
+
+test:
+  adapter: postgresql
+  database: biorails_test
+  username: rails
+  password: 
+  
+production:
+  adapter: postgresql
+  database: biorails_production
+  username: rails
+  password: 

data/lib/bio/io/sql.rb

@@ -0,0 +1,79 @@
+#module Bio
+ # class SQL
+  #  #no check is made
+   # def self.establish_connection(configurations, env)
+    #  #configurations is an hash similar what YAML returns.
+     # #{:database=>"biorails_development", :adapter=>"postgresql", :username=>"rails", :password=>nil}
+     # configurations.assert_valid_keys('development', 'production','test')
+     # configurations[env].assert_valid_keys('hostname','database','adapter','username','password')
+     # DummyBase.configurations = configurations
+     # DummyBase.establish_connection "#{env}"
+    #end
+
+
+#require 'rubygems'
+#require 'composite_primary_keys'
+#require 'erb'
+# BiosqlPlug
+
+=begin
+Ok Hilmar gives to me some clarification
+1) "EMBL/GenBank/SwissProt" name in term table, is only a convention assuming data loaded by genbank embl ans swissprot formats.
+   If your features come from others ways for example blast or alignment ... whatever.. the user as to take care about the source.
+
+
+=end
+=begin
+TODO:
+1) source_term_id => surce_term and check before if the source term is present or not and the level, the root should always be something "EMBL/GenBank/SwissProt" or contestualized.
+2) Into DummyBase class delete connection there and use Bio::ArSQL.establish_connection which reads info from a yml file.
+3) Chk Locations in Biofeatures ArSQL
+=end
+module Bio
+  class SQL
+
+    require 'bio/io/biosql/biosql'
+    autoload :Sequence, 'bio/db/biosql/sequence'
+
+    def self.fetch_id(id)
+      Bio::SQL::Bioentry.find(id)
+    end
+
+    def self.fetch_accession(accession)
+#     Bio::SQL::Bioentry.exists?(:accession => accession) ? Bio::SQL::Sequence.new(:entry=>Bio::SQL::Bioentry.find_by_accession(accession)) : nil
+      Bio::SQL::Sequence.new(:entry=>Bio::SQL::Bioentry.find_by_accession(accession.upcase))
+    end
+
+    def self.exists_accession(accession)
+#      Bio::SQL::Bioentry.find_by_accession(accession.upcase).nil? ? false : true
+      !Bio::SQL::Bioentry.find_by_accession(accession.upcase).nil?
+    end
+
+    def self.exists_database(name)
+#      Bio::SQL::Biodatabase.find_by_name(name).nil? ? false : true
+      !Bio::SQL::Biodatabase.first(:name=>name).nil?
+    end
+
+    def self.list_entries
+      Bio::SQL::Bioentry.all.collect do|entry|
+        {:id=>entry.bioentry_id, :accession=>entry.accession}
+      end
+    end
+
+    def self.list_databases
+      Bio::SQL::Biodatabase.all.collect do|entry|
+        {:id=>entry.biodatabase_id, :name => entry.name}
+      end
+    end
+
+    def self.delete_entry_id(id)
+      Bio::SQL::Bioentry.delete(id)
+    end
+
+    def self.delete_entry_accession(accession)
+      Bio::SQL::Bioentry.find_by_accession(accession.upcase).destroy!
+    end
+
+  end #biosql
+
+end #Bio

data/test/bioruby_test_helper.rb

@@ -0,0 +1,86 @@
+#
+# test/bioruby_test_helper.rb - Helper module for testing bioruby
+#
+# Copyright::  Copyright (C) 2009 Naohisa Goto <ng@bioruby.org>
+# License::    The Ruby License
+#
+
+require 'pathname'
+
+unless defined? BioRubyTestDebug then
+  BioRubyTestDebug = ENV['BIORUBY_TEST_DEBUG'].to_s.empty? ? false : true
+  if BioRubyTestDebug then
+    $stderr.puts "BioRuby test debug enabled."
+  end
+end #BioRubyTestDebug
+
+unless defined? BioRubyTestGem then
+  gem_version = ENV['BIORUBY_TEST_GEM']
+  if gem_version then
+    $stderr.puts 'require "rubygems"' if BioRubyTestDebug
+    require "rubygems"
+    if gem_version.empty? then
+      $stderr.puts "gem 'bio'" if BioRubyTestDebug
+      gem 'bio'
+    else
+      $stderr.puts "gem 'bio', #{gem_version.inspect}" if BioRubyTestDebug
+      gem 'bio', gem_version
+    end
+  end
+  BioRubyTestGem = gem_version
+end
+
+unless defined? BioRubyTestLibPath then
+  libpath = ENV['BIORUBY_TEST_LIB']
+  unless libpath then
+    libpath = Pathname.new(File.join(File.dirname(__FILE__),
+                                     "..", "lib")).cleanpath.to_s
+  end
+
+  # do not add path to $: if BIORUBY_TEST_LIB is empty string
+  # or BioRubyTestGem is true.
+  if (libpath and libpath.empty?) or BioRubyTestGem then
+    libpath = nil
+  end
+
+  if libpath then
+    libpath.freeze
+
+    unless $:[0] == libpath then
+      $:.unshift(libpath)
+      if BioRubyTestDebug then
+        $stderr.puts "Added #{libpath.inspect} to $:."
+      end
+    else
+      if BioRubyTestDebug then
+        $stderr.puts "NOT added #{libpath.inspect} to $:. because it is already on the top of $:."
+      end
+    end
+  end
+
+  # (String or nil) Path to be added to $:.
+  # It may or may not be the path of bioruby.
+  BioRubyTestLibPath = libpath
+  
+  if BioRubyTestDebug then
+    $stderr.print "$: = [", "\n"
+    $stderr.puts($:.collect { |x| "\t#{x.inspect}" }.join(",\n"))
+    $stderr.print "]", "\n"
+  end
+end #BioRubyTestLibPath
+
+unless defined? BioRubyTestDataPath and BioRubyTestDataPath
+  datapath = ENV['BIORUBY_TEST_DATA']
+  if datapath.to_s.empty? then
+    datapath = Pathname.new(File.join(File.dirname(__FILE__),
+                                      "data")).cleanpath.to_s
+  end
+  datapath.freeze
+
+  # (String) Path to the test data.
+  BioRubyTestDataPath = datapath
+  
+  if BioRubyTestDebug then
+    $stderr.print "DataPath = ", BioRubyTestDataPath.inspect, "\n"
+  end
+end