bio-nexml 0.0.1

data/lib/bio/db/nexml.rb

@@ -0,0 +1,109 @@
+#load XML library for parser and serializer
+require 'xml'
+
+#load required class and module definitions
+require "bio/db/nexml/mapper"
+
+#Autoload definition
+module Bio
+  module NeXML
+    
+    @@id_counter = 0;
+    def self.generate_id( klass )
+      myname = klass.name
+      local = myname.gsub(/.*:/,"")
+      @@id_counter += 1
+      newid = @@id_counter
+      "#{local}#{newid}"
+    end    
+
+    module Base
+      attr_accessor :xml_base
+      attr_accessor :xml_id
+      attr_accessor :xml_lang
+      attr_accessor :xml_space
+    end #end module Base
+
+    # Autoload multiple modules that reside in the same file.
+    def self.mautoload( modules, file )
+      modules.each do |m|
+        autoload m, file
+      end
+    end
+
+    mautoload %w|Otu Otus|,                                'bio/db/nexml/taxa.rb'
+    mautoload %w|Node Edge Tree Network Trees|,            'bio/db/nexml/trees.rb'
+    mautoload %w|State Char States Cell Sequence Format Characters|,  'bio/db/nexml/matrix.rb'
+
+    autoload :Parser, 'bio/db/nexml/parser'
+    autoload :Writer, 'bio/db/nexml/writer'
+
+    class Nexml
+      @@writer = Bio::NeXML::Writer.new      
+      include Mapper
+      include Enumerable
+      attr_accessor :version
+      attr_accessor :generator
+
+      has_n :otus,       :singularize => false
+      has_n :trees,      :singularize => false
+      has_n :characters, :singularize => false
+      
+      def initialize( version = '0.9', generator = 'bioruby' )
+        @version = version
+        @generator = generator
+      end
+
+      # Append a Otus, Trees, or Characters object to any
+      # Nexml object.
+      def <<( element )
+        case element
+        when Otus
+          add_otus element
+        when Trees
+          add_trees element
+        when Characters
+          add_characters element
+        end
+      end
+      
+      def create_otus( options = {} )
+        otus = Otus.new( Bio::NeXML.generate_id( Otus ), options )
+        self << otus
+        otus        
+      end
+      
+      def create_trees( options )
+        trees = Trees.new( Bio::NeXML.generate_id( Trees ), options )
+        self << trees
+        trees
+      end
+      
+      def create_characters( type = "Dna", verbose = false, options = {} )
+        subtype = verbose ? "Cells" : "Seqs"
+        klass_name = "#{type.to_s.capitalize}#{subtype}"
+        klass = NeXML.const_get( klass_name )
+        characters = klass.new( Bio::NeXML.generate_id( klass ), options )
+        self << characters
+        characters
+      end
+      
+      def to_xml
+        node = @@writer.create_node( "nex:nexml", :"xsi:schemaLocation" => "http://www.nexml.org/2009 http://www.nexml.org/2009/xsd/nexml.xsd", :generator => generator, :version => version )
+        node.namespaces = { nil => "http://www.nexml.org/2009", :xsi => "http://www.w3.org/2001/XMLSchema-instance", :xlink => "http://www.w3.org/1999/xlink", :nex => "http://www.nexml.org/2009" }
+        self.each_otus do |otus|
+            node << otus.to_xml
+        end
+        self.each_characters do |characters|
+            node << characters.to_xml
+        end
+        self.each_trees do |trees|
+            node << trees.to_xml
+        end        
+        node
+      end      
+      
+    end #end class Nexml
+  end
+end
+

data/lib/bio/db/nexml/mapper.rb

@@ -0,0 +1,113 @@
+require 'bio/db/nexml/mapper/inflection'
+require 'bio/db/nexml/mapper/repository'
+require 'bio/db/nexml/mapper/framework'
+
+module Bio
+  module NeXML
+
+    # Mapper provides a very small DSL for defining NeXML classes, specifically one-to-many relation
+    # between classes as they are found a lot in NeXML. Though the style has been borrowed from
+    # ActiveRecord, it should not be mistaken for an ORM. It just factors out repetitive chunk of
+    # code that would otherwise be present.
+    # 
+    # Including Mapper in a class, creates <tt>has_n</tt>, and <tt>belongs_to</tt> class methods
+    # by extending Framework module.  These methods are used to define a one-to-many relation
+    # between two classes. Two types of one-to-many relation occurs in NeXML.
+    # * parent-child - an element <em>contains</em> other elements. In raw NeXML it would mean
+    # nested elements.
+    # * association  - an element <em>refers</em> to other elements. In raw NeXML it would mean
+    # a source element, referred to by several targets.
+    #
+    # Their implementation however is same. Defining a relation automatically creates methods to
+    # add, delete and query objects.
+    # 
+    #    class Otu
+    #      property   :id
+    #      belongs_to :otus
+    #    end
+    #
+    #    class Otus
+    #      property :id
+    #      has_n    :otus
+    #    end
+    #
+    #    t1 = Otu.new
+    #    t1.id = 't1'
+    #    t2 = Otu.new
+    #    t2.id = 't2'
+    #    o1 = Otus.new
+    #    o1.id = 'o1'
+    #
+    #    # add to source
+    #    o1.add_otu( t1 )          
+    #    o1.otus
+    #    => [ t1 ]
+    #    t1.otus
+    #    => o1
+    #
+    #    # add to target
+    #    t2.otus = o1              
+    #    o1.otus
+    #    => [ t1, t2 ]
+    #    t2.otus
+    #    => o1
+    #
+    #    # query from source
+    #    o1.has_otu?( t1 )
+    #    => true
+    #    o1.get_otu_by_id( 't1' )
+    #    => t1
+    #
+    #    # delete from source
+    #    o1.delete_otu( t1 )
+    #    o1.otus
+    #    => [ t2 ]
+    #    t1.otus
+    #    => nil
+    module Mapper # :nodoc: all
+
+      # Gets or sets properties of the receiver.
+      def properties( args = {} )
+        @properties ||= {}
+
+        # set properties if defined
+        args.each do |property, value|
+          raise "#{property} not defined" unless respond_to?( setter = "#{property}=" )
+          send( setter, value )
+        end unless args.empty?
+
+        # return a copy of @properties so that it is not modified inadvertently by the user
+        @properties.dup
+      end
+      alias properties= properties
+
+      private
+
+      # Fetches an instance variable corresponding to name. If the instance variable
+      # is nil, set it to defaul value and return it.
+      def repository( name, type = HashRepository )
+        ivget( name ) || ivset( name, type.new )
+      end
+
+      # Return an instance variable corresponding to the given name.
+      # '@' is automatically prepended to the name.
+      #    object.ivget( 'name' ) #=> returns value of @name
+      #    object.ivget( :name )  #=> returns value of @name
+      def ivget( name )
+        instance_variable_get( "@#{name}" )
+      end
+
+      # Set an instance variable corresponding to the given name.
+      # '@' is automatically prepended to the name.
+      #    object.ivset( 'name', value ) #=> sets @name to value
+      #    object.ivget( :name, value )  #=> sets @name to value
+      def ivset( name, value = nil )
+        instance_variable_set( "@#{name}", value )
+      end
+
+      def self.included( klass )
+        klass.extend Framework
+      end
+    end #end module Mapper
+  end #end module NeXML
+end #end module Bio

data/lib/bio/db/nexml/mapper/framework.rb

@@ -0,0 +1,157 @@
+module Bio
+  module NeXML
+    module Mapper
+
+      # Framework is the real workhorse of Mapper.
+      module Framework
+
+        # Define a source for the target.
+        #    belongs_to :source
+        def belongs_to( name, options = {} )
+          update = ( options[ :update ] || self.name.key ).to_sym
+
+          # create attribute reader for source
+          attr_reader name
+
+          # Add this target to a source.
+          #    def add_to_source( source )
+          #      return if @source == source or source.nil?
+          #      @source = source
+          #      source.add_target( self )
+          #    end
+          define_method( "add_to_#{name}" ) do |source,|
+            # return if the target already belongs to
+            # the given source or if the source is nil.
+            return if ivget( name ) == source or source.nil?
+
+            # add source and send a message to source
+            # to add self as target.
+            ivset( name, source )
+            source.send( "add_#{update}", self )
+          end
+
+          # Set or remove source.
+          #    def source=( source )
+          #      return remove_from_source if source.nil?
+          #      return add_to_source( self )
+          #    end
+          define_method( "#{name}=" ) do |source,|
+            return send( "remove_from_#{name}" ) if source.nil?
+            return send( "add_to_#{name}", source )
+          end
+
+          # Remove this target from an existing source.
+          #    def remove_from_source
+          #      return unless source = @source
+          #      @source = nil
+          #      source.delete_target( self )
+          #    end
+          define_method( "remove_from_#{name}" ) do
+            # return if a sourc is not set.
+            return unless source = ivget( name )
+
+            # remove source and send a message to source
+            # to remove itself as target.
+            ivset( name, nil )
+            source.send( "delete_#{update}", self )
+          end
+        end
+
+        # Define target set for the source.
+           # has_n :otu
+        def has_n( target, options = {} )
+          name = ( options[ :singularize ] == false ) ? target.to_s : target.to_s.singular
+          type = ( options[ :index ] == false ) ? ArrayRepository : HashRepository
+          update = ( options[ :update ] || self.name.key ).to_sym
+
+          # Return an Array of targets.
+          #    def targets
+          #      @targets.objects
+          #    end
+          define_method( target ) do
+            repository( target, type ).objects
+          end
+
+          # Set an Array as a target.
+          #    def targets=( targets )
+          #      @targets.clear
+          #      targets.each do |t|
+          #        add_target( t )
+          #      end
+          #    end
+          define_method( "#{target}=" ) do |objects,|
+            repository( target, type ).clear
+            objects.each do |o|                     
+              send( "add_#{name}", o )  
+            end                        
+          end                         
+
+          # Add a target.
+          #    def add_target( target )
+          #      return if @targets.include?( target )
+          #      @targets.append( target )
+          #      target.source = self
+          #    end
+          define_method( "add_#{name}" ) do |object,|
+            repository = repository( target, type )
+            return if repository.include?( object )
+            repository.append( object )
+            object.send( "#{update}=", self )
+            self
+          end
+
+          # Delete a target.
+          #    def delete_target( target )
+          #      return unless @targets.include?( target )
+          #      return unless deleted = @targets.delete( target )
+          #      target.source = nil
+          #    end
+          define_method( "delete_#{name}" ) do |object,|
+            repository = repository( target, type )
+            return unless deleted = repository.delete( object )
+            object.send( "#{update}=", nil )
+            deleted
+          end                                          
+
+          # Return the number of targets a source has.
+          #    def number_of_targets
+          #      @targets.length
+          #    end
+          define_method( "number_of_#{target}" ) do
+            repository( target, type ).length
+          end
+
+          # Return true if the source has the given target.
+          #    def has_target?( target )
+          #      @targets.include?( target )
+          #    end
+          define_method( "has_#{name}?" ) do |object,|
+            repository( target, type ).include?( object )
+          end
+
+          # Iterate over each target.
+          #    def each( &block )
+          #      @targets.each( &block )
+          #    end
+          class_eval <<_END_OF_EVAL_
+            def each_#{name}( &block )
+              repository( "#{target}", #{type} ).each( &block )
+            end
+_END_OF_EVAL_
+
+          if type == HashRepository
+            define_method( "get_#{name}_by_id" ) do |id,|
+              repository( target, type )[ id ]          
+            end                                        
+          class_eval <<_END_OF_EVAL_
+            def each_#{name}_with_id( &block )
+              repository( #{target }, #{type } ).each_with_id( &block )
+            end
+_END_OF_EVAL_
+          end
+        end
+
+      end #end module Framework
+    end #end module Mapper
+  end #end module NeXML
+end #end module Mapper

data/lib/bio/db/nexml/mapper/inflection.rb

@@ -0,0 +1,99 @@
+module Bio
+  module NeXML
+    module Mapper # :nodoc: 
+
+      # String inflections. This module is mixed with the String class.
+      #
+      #    "targets".singular     #=> "target"
+      #    "target".plural        #=> "targets"
+      #    "Bio::NeXML::Otu".key  #=> "otu"
+      module Inflections
+        PLURALS =
+          [
+            [ /$/, 's' ],
+            [ /s$/i, 's' ],
+            [ /(ax|test)is$/i, '\1es' ],
+            [ /(octop|vir)us$/i, '\1i' ],
+            [ /(alias|status)$/i, '\1es' ],
+            [ /(bu)s$/i, '\1ses' ],
+            [ /(buffal|tomat)o$/i, '\1oes' ],
+            [ /([ti])um$/i, '\1a' ],
+            [ /sis$/i, 'ses' ],
+            [ /(?:([^f])fe|([lr])f)$/i, '\1\2ves' ],
+            [ /(hive)$/i, '\1s' ],
+            [ /([^aeiouy]|qu)y$/i, '\1ies' ],
+            [ /(x|ch|ss|sh)$/i, '\1es' ],
+            [ /(matr|vert|ind)(?:ix|ex)$/i, '\1ices' ],
+            [ /([m|l])ouse$/i, '\1ice' ],
+            [ /^(ox)$/i, '\1en' ],
+            [ /(quiz)$/i, '\1zes' ]
+        ]
+
+        SINGULARS = 
+          [
+            [ /s$/i, '' ],
+            [ /(n)ews$/i, '\1ews' ],
+            [ /([ti])a$/i, '\1um' ],
+            [ /((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '\1\2sis' ],
+            [ /(^analy)ses$/i, '\1sis' ],
+            [ /([^f])ves$/i, '\1fe' ],
+            [ /(hive)s$/i, '\1' ],
+            [ /(tive)s$/i, '\1' ],
+            [ /([lr])ves$/i, '\1f' ],
+            [ /([^aeiouy]|qu)ies$/i, '\1y' ],
+            [ /(s)eries$/i, '\1eries' ],
+            [ /(m)ovies$/i, '\1ovie' ],
+            [ /(x|ch|ss|sh)es$/i, '\1' ],
+            [ /([m|l])ice$/i, '\1ouse' ],
+            [ /(bus)es$/i, '\1' ],
+            [ /(o)es$/i, '\1' ],
+            [ /(shoe)s$/i, '\1' ],
+            [ /(cris|ax|test)es$/i, '\1is' ],
+            [ /(octop|vir)i$/i, '\1us' ],
+            [ /(alias|status)es$/i, '\1' ],
+            [ /^(ox)en/i, '\1' ],
+            [ /(vert|ind)ices$/i, '\1ex' ],
+            [ /(matr)ices$/i, '\1ix' ],
+            [ /(quiz)zes$/i, '\1' ],
+            [ /(database)s$/i, '\1' ]
+        ]
+
+        # Return the singular form of string.
+        def singular
+          result = self.dup
+          SINGULARS.each do |match, replace|
+            rule = Regexp.compile( match )
+            unless match( rule ).nil?
+              result = gsub( rule, replace) 
+            end
+          end
+          return result
+        end
+
+        # Return the plural form of a string.
+        def plural
+          result = self.dup
+          PLURALS.each do |match_exp, replacement_exp|
+            unless match(Regexp.compile(match_exp)).nil?
+              result =  gsub(Regexp.compile(match_exp), replacement_exp)
+            end
+          end
+          return result
+        end
+
+        # For a module name as "Bio::NeXML" return "nexml".
+        def key
+          result = self.dup
+          if i = rindex( ':' )
+            result = self[ i + 1 .. -1 ]
+          end
+          result.downcase
+        end
+      end # end module Inflections
+
+      String.class_eval do
+        include Inflections
+      end
+    end #end module Mapper
+  end #end module NeXML
+end #end module Bio