bio 1.5.2 → 1.6.0.pre.20181210

data/lib/bio/db/phyloxml/phyloxml_writer.rb

@@ -1,227 +0,0 @@
-#
-# = bio/db/phyloxml_writer.rb - PhyloXML writer
-#
-# Copyright::   Copyright (C) 2009
-#               Diana Jaunzeikare <latvianlinuxgirl@gmail.com>
-# License::     The Ruby License
-#
-#
-# == Description
-#
-# This file containts writer for PhyloXML.
-#
-# == Requirements
-#
-# Libxml2 XML parser is required. Install libxml-ruby bindings from
-# http://libxml.rubyforge.org or
-#
-#   gem install -r libxml-ruby
-#
-# == References
-#
-# * http://www.phyloxml.org
-#
-# * https://www.nescent.org/wg_phyloinformatics/PhyloSoC:PhyloXML_support_in_BioRuby
-
-require 'libxml'
-require 'bio/db/phyloxml/phyloxml_elements'
-
-module Bio
-
-  module PhyloXML
-
-  # == Description
-  #
-  # Bio::PhyloXML::Writer is for writing phyloXML (version 1.10) format files.
-  #
-  # == Requirements
-  #
-  # Libxml2 XML parser is required. Install libxml-ruby bindings from
-  # http://libxml.rubyforge.org or
-  #
-  #   gem install -r libxml-ruby
-  #
-  # == Usage
-  #
-  #   require 'bio'
-  #
-  #  # Create new phyloxml parser
-  #  phyloxml = Bio::PhyloXML::Parser.open('example.xml')
-  #
-  #  # Read in some trees from file
-  #  tree1 = phyloxml.next_tree
-  #  tree2 = phyloxml.next_tree
-  #
-  #  # Create new phyloxml writer
-  #  writer = Bio::PhyloXML::Writer.new('tree.xml')
-  #
-  #  # Write tree to the file tree.xml
-  #  writer.write(tree1)
-  #
-  #  # Add another tree to the file
-  #  writer.write(tree2)
-  #
-  # == References
-  #
-  # http://www.phyloxml.org/documentation/version_100/phyloxml.xsd.html
-
-    class Writer
-
-      include LibXML
-
-      SCHEMA_LOCATION = 'http://www.phyloxml.org http://www.phyloxml.org/1.10/phyloxml.xsd'
-            
-      attr_accessor :write_branch_length_as_subelement
-
-      #
-      # Create new Writer object. As parameters provide filename of xml file
-      # you wish to create. Optional parameter is whether to indent or no.
-      # Default is true. By default branch_length is written as subelement of
-      # clade element.
-      #
-      def initialize(filename, indent=true)
-      @write_branch_length_as_subelement = true #default value
-      @filename = filename
-      @indent = indent
-
-      @doc = XML::Document.new()
-      @doc.root = XML::Node.new('phyloxml')
-      @root = @doc.root
-      @root['xmlns:xsi'] = 'http://www.w3.org/2001/XMLSchema-instance'
-      @root['xsi:schemaLocation'] = SCHEMA_LOCATION
-      @root['xmlns'] = 'http://www.phyloxml.org'
-
-      #@todo save encoding to be UTF-8. (However it is the default one).
-      #it gives error NameError: uninitialized constant LibXML::XML::Encoding
-      #@doc.encoding = XML::Encoding::UTF_8
-
-      @doc.save(@filename, :indent => true)
-      end
-
-      #
-      # Write a tree to a file in phyloxml format.
-      #
-      #  require 'Bio'
-      #  writer = Bio::PhyloXML::Writer.new
-      #  writer.write(tree)
-      #
-      def write(tree)
-        @root << phylogeny = XML::Node.new('phylogeny')        
-        
-        PhyloXML::Writer.generate_xml(phylogeny, tree, [
-            [:attr, 'rooted'],
-            [:simple, 'name', tree.name],
-            [:complex, 'id', tree.phylogeny_id],
-            [:simple, 'description', tree.description],
-            [:simple, 'date', tree.date],
-            [:objarr, 'confidence', 'confidences']])
-
-        root_clade = tree.root.to_xml(nil, @write_branch_length_as_subelement)
-        
-        phylogeny << root_clade 
-
-        tree.children(tree.root).each do |node|
-          root_clade << node_to_xml(tree, node, tree.root)
-        end
-
-        Bio::PhyloXML::Writer::generate_xml(phylogeny, tree, [
-            [:objarr, 'clade_relation', 'clade_relations'],
-            [:objarr, 'sequence_relation', 'sequence_relations'],
-            [:objarr, 'property', 'properties']] )
-
-        @doc.save(@filename, :indent => @indent)
-      end #writer#write
-
-
-      #
-      # PhyloXML Schema allows to save data in different xml format after all
-      # phylogeny elements. This method is to write these additional data.
-      #
-      #  parser = PhyloXML::Parser.open('phyloxml_examples.xml')
-      #  writer = PhyloXML::Writer.new('new.xml')
-      #
-      #  parser.each do |tree|
-      #    writer.write(tree)
-      #  end
-      #
-      #  # When all the trees are read in by the parser, whats left is saved at
-      #  # PhyloXML::Parser#other
-      #  writer.write(parser.other)
-      #
-
-      def write_other(other_arr)
-        other_arr.each do |other_obj|
-          @root << other_obj.to_xml
-        end
-        @doc.save(@filename, :indent => @indent)
-      end
-
-      #class method
-
-      #
-      # Used by to_xml methods of PhyloXML element classes. Generally not to be
-      # invoked directly. 
-      #
-      def self.generate_xml(root, elem, subelement_array)
-       #example usage: generate_xml(node, self, [[ :complex,'accession', ], [:simple, 'name',  @name], [:simple, 'location', @location]])
-      subelement_array.each do |subelem|
-        if subelem[0] == :simple         
-          root << XML::Node.new(subelem[1], subelem[2].to_s) if subelem[2] != nil and not subelem[2].to_s.empty?
-
-        elsif subelem[0] == :complex
-          root << subelem[2].send("to_xml") if subelem[2] != nil
-
-        elsif subelem[0] == :pattern
-          #seq, self, [[:pattern, 'symbol', @symbol, "\S{1,10}"]
-          if subelem[2] != nil
-            if subelem[2] =~ subelem[3]
-              root << XML::Node.new(subelem[1], subelem[2])
-            else
-              raise "#{subelem[2]} is not a valid value of #{subelem[1]}. It should follow pattern #{subelem[3]}"
-            end
-          end
-
-        elsif subelem[0] == :objarr
-          #[:objarr, 'annotation', 'annotations']])
-          obj_arr = elem.send(subelem[2])
-          obj_arr.each do |arr_elem|
-            root << arr_elem.to_xml
-          end
-
-        elsif subelem[0] == :simplearr
-          #  [:simplearr, 'common_name', @common_names]
-          subelem[2].each do |elem_val|
-            root << XML::Node.new(subelem[1], elem_val)
-          end
-        elsif subelem[0] == :attr
-          #[:attr, 'rooted']
-          obj = elem.send(subelem[1])
-          if obj != nil
-            root[subelem[1]] = obj.to_s
-          end
-        else
-          raise "Not supported type of element by method generate_xml."
-        end
-      end
-      return root
-      end
-
-      private
-
-      def node_to_xml(tree, node, parent)
-        edge = tree.get_edge(parent, node)
-        branch_length = edge.distance
-
-        clade = node.to_xml(branch_length, @write_branch_length_as_subelement)
-
-        tree.children(node).each do |new_node|
-          clade << node_to_xml(tree, new_node, node)
-        end
-
-        return clade
-      end
-
-    end
-
-  end
-end

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

@@ -1,257 +0,0 @@
-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