bel 0.2.1 → 0.3.0.beta1

data/lib/bel/namespace.rb

@@ -1,5 +1,7 @@
 require 'open-uri'
-require_relative './language' 
+
+require_relative '../features'
+require_relative './language'
 
 class String
   def split_by_last(char=" ")
@@ -11,7 +13,102 @@ end
 module BEL
   module Namespace
 
-    NAMESPACE_HASH = {
+    LATEST_PREFIX = 'http://resource.belframework.org/belframework/latest-release/'
+    DEFAULT_URI = 'http://www.openbel.org/bel/namespace/'
+
+    NAMESPACE_LATEST = {
+      AFFX: [
+        LATEST_PREFIX + 'namespace/affy-probeset-ids.belns',
+        'http://www.openbel.org/bel/namespace/affy-probeset'
+      ],
+      CHEBI: [
+        LATEST_PREFIX + 'namespace/chebi.belns',
+        'http://www.openbel.org/bel/namespace/chebi'
+      ],
+      CHEBIID: [
+        LATEST_PREFIX + 'namespace/chebi-ids.belns',
+        'http://www.openbel.org/bel/namespace/chebi'
+      ],
+      DO: [
+        LATEST_PREFIX + 'namespace/disease-ontology.belns',
+        'http://www.openbel.org/bel/namespace/disease-ontology'
+      ],
+      DOID: [
+        LATEST_PREFIX + 'namespace/disease-ontology-ids.belns',
+        'http://www.openbel.org/bel/namespace/disease-ontology'
+      ],
+      EGID: [
+        LATEST_PREFIX + 'namespace/entrez-gene-ids.belns',
+        'http://www.openbel.org/bel/namespace/entrez-gene'
+      ],
+      GOBP: [
+        LATEST_PREFIX + 'namespace/go-biological-process.belns',
+        'http://www.openbel.org/bel/namespace/go-biological-processes'
+      ],
+      GOBPID: [
+        LATEST_PREFIX + 'namespace/go-biological-process-ids.belns',
+        'http://www.openbel.org/bel/namespace/go'
+      ],
+      GOCC: [
+        LATEST_PREFIX + 'namespace/go-cellular-component.belns',
+        'http://www.openbel.org/bel/namespace/go-cellular-component'
+      ],
+      GOCCID: [
+        LATEST_PREFIX + 'namespace/go-cellular-component-ids.belns',
+        'http://www.openbel.org/bel/namespace/go-cellular-component'
+      ],
+      HGNC: [
+        LATEST_PREFIX + 'namespace/hgnc-human-genes.belns',
+        'http://www.openbel.org/bel/namespace/hgnc-human-genes'
+      ],
+      MESHCS: [
+        LATEST_PREFIX + 'namespace/mesh-cellular-structures.belns',
+        'http://www.openbel.org/bel/namespace/mesh-cellular-structures'
+      ],
+      MESHD: [
+        LATEST_PREFIX + 'namespace/mesh-diseases.belns',
+        'http://www.openbel.org/bel/namespace/mesh-diseases',
+      ],
+      MESHPP: [
+        LATEST_PREFIX + 'namespace/mesh-processes.belns',
+        'http://www.openbel.org/bel/namespace/mesh-processes'
+      ],
+      MGI: [
+        LATEST_PREFIX + 'namespace/mgi-mouse-genes.belns',
+        'http://www.openbel.org/bel/namespace/mgi-mouse-genes'
+      ],
+      RGD: [
+        LATEST_PREFIX + 'namespace/rgd-rat-genes.belns',
+        'http://www.openbel.org/bel/namespace/rgd-rat-genes'
+      ],
+      SCOMP: [
+        LATEST_PREFIX + 'namespace/selventa-named-complexes.belns',
+        'http://www.openbel.org/bel/namespace/selventa-named-complexes'
+      ],
+      SCHEM: [
+        LATEST_PREFIX + 'namespace/selventa-legacy-chemicals.belns',
+        'http://www.openbel.org/bel/namespace/selventa-legacy-chemicals'
+      ],
+      SDIS: [
+        LATEST_PREFIX + 'namespace/selventa-legacy-diseases.belns',
+        'http://www.openbel.org/bel/namespace/selventa-legacy-diseases'
+      ],
+      SFAM: [
+        LATEST_PREFIX + 'namespace/selventa-protein-families.belns',
+        'http://www.openbel.org/bel/namespace/selventa-protein-families'
+      ],
+      SP: [
+        LATEST_PREFIX + 'namespace/swissprot.belns',
+        'http://www.openbel.org/bel/namespace/swissprot'
+      ],
+      SPAC: [
+        LATEST_PREFIX + 'namespace/swissprot-ids.belns',
+        'http://www.openbel.org/bel/namespace/swissprot-ids'
+      ]
+    }
+
+    # XXX 1.0 namespaces without rdf support
+    NAMESPACE_BELNS = {
       HGU95AV2:  'http://resource.belframework.org/belframework/1.0/namespace/affy-hg-u95av2.belns',
       HGU133P2:  'http://resource.belframework.org/belframework/1.0/namespace/affy-hg-u133-plus2.belns',
       HGU133AB:  'http://resource.belframework.org/belframework/1.0/namespace/affy-hg-u133ab.belns',
@@ -46,61 +143,180 @@ module BEL
       SP:        'http://resource.belframework.org/belframework/1.0/namespace/swissprot-entry-names.belns'
     }
 
+    class ResourceIndex
+      include Enumerable
+
+      class << self
+        def openbel_published_index(version)
+          clean = version.to_s.strip
+          ResourceIndex.new("http://resource.belframework.org/belframework/#{clean}/index.xml")
+        end
+      end
+
+      attr_writer :namespaces
+      attr_writer :annotations
+
+      def initialize(index, namespaces = [], annotations = [])
+        @index = index
+        @namespaces = namespaces
+        @annotations = annotations
+        @loaded = false
+      end
+
+      def namespaces
+        read_index if not @loaded
+        @namespaces
+      end
+
+      def annotations
+        read_index if not @loaded
+        @annotations
+      end
+
+      def each
+        read_index if not @loaded
+        @namespaces.each { |x| yield x }
+        @annotations.each { |x| yield x }
+      end
+
+      def each_namespace
+        read_index if not @loaded
+        @namespaces.each { |x| yield x }
+      end
+
+      def each_annotation
+        read_index if not @loaded
+        @annotations.each { |x| yield x }
+      end
+
+      def to_bel
+        map { |x| x.to_bel }
+      end
+
+      private
+
+      def read_index
+        return if not @index or @index.empty?
+
+        data = BEL::read_all(@index)
+        @namespaces += data.
+          scan(%r{<(idx:)?namespace (idx:)?resourceLocation="(.*)"}).
+          map { |matches|
+            url = matches[2]
+            prefix = BEL::read_lines(url).find { |line|
+              line.start_with? 'Keyword'
+            }.split('=').map(&:strip)[1].to_sym
+            NamespaceDefinition.new(prefix, url)
+          }
+        @annotations += data.
+          scan(%r{<(idx:)?annotationdefinition (idx:)?resourceLocation="(.*)"}).
+          map { |matches|
+            url = matches[2]
+            prefix = BEL::read_lines(url).find { |line|
+              line.start_with? 'Keyword'
+            }.split('=').map(&:strip)[1].to_sym
+            BEL::Language::AnnotationDefinition.new(:url, prefix, url)
+          }
+
+        @loaded = true
+      end
+    end
+
     class NamespaceDefinition
       include Enumerable
 
+      attr_reader :prefix
       attr_reader :url
-      attr_reader :values
+      attr_reader :rdf_uri
 
-      def initialize(prefix, url)
+      def initialize(prefix, url, rdf_uri = DEFAULT_URI)
         @prefix = prefix
         @url = url
+        @rdf_uri = rdf_uri
         @values = nil
       end
 
+      def values
+        unless @values
+          reload(@url)
+        end
+        @values
+      end
+
       def [](value)
         return nil unless value
-
         reload(@url) if not @values
         sym = value.to_sym
-        Language::Parameter.new(@prefix, sym,
-                                @values[sym]) if @values.key?(sym)
+        encoding = @values[sym] || :""
+        Language::Parameter.new(self, sym, encoding)
       end
 
       def each &block
         reload(@url) if not @values
-        ns = @prefix.to_sym
         @values.each do |val, enc|
           if block_given?
-            block.call(Language::Parameter.new(ns, val, enc))
+            block.call(Language::Parameter.new(self, val, enc))
           else
-            yield Language::Parameter.new(ns, val, enc)
+            yield Language::Parameter.new(self, val, enc)
           end
         end
       end
 
+      def hash
+        [@prefix, @url].hash
+      end
+
+      def ==(other)
+        return false if other == nil
+        @prefix == other.prefix && @url == other.url
+      end
+
+      alias_method :eql?, :'=='
+
+      def to_s
+        @prefix.to_s
+      end
+
+      def to_bel
+        %Q{DEFINE NAMESPACE #{@prefix} AS URL "#{@url}"}
+      end
+
       private
       # the backdoor
       def reload(url)
         @values = {}
-        open(url).
-          drop_while { |i| not i.start_with? "[Values]" }.
-          drop(1).
-          each do |s|
-            val_enc = s.strip!.split_by_last('|').map(&:to_sym)
-            @values[val_enc[0]] = val_enc[1]
-          end
+        BEL::read_lines(url).
+        drop_while { |i| not i.start_with? "[Values]" }.
+        drop(1).
+        each do |s|
+          val_enc = s.strip!.split_by_last('|').map(&:to_sym)
+          @values[val_enc[0]] = val_enc[1]
+        end
+      end
+    end
+
+    if BEL::Features.rdf_support?
+      require_relative 'rdf'
+
+      class NamespaceDefinition
+        def to_uri
+          @rdf_uri
+        end
+
+        def to_rdf_vocabulary
+          RUBYRDF::Vocabulary.new("#{@rdf_uri}/")
+        end
       end
     end
 
     # create classes for each standard prefix
-    DEFAULT_NAMESPACES = [
-      NAMESPACE_HASH.collect do |prefix, default_url|
-        ns_definition = NamespaceDefinition.new(prefix, default_url)
+    DEFAULT_NAMESPACES =
+      NAMESPACE_LATEST.collect do |prefix, values|
+        rdf_uri = NAMESPACE_LATEST[prefix][1] || DEFAULT_URI
+        ns_definition = NamespaceDefinition.new(prefix, values[0], rdf_uri)
         Namespace.const_set(prefix, ns_definition)
         ns_definition
       end
-    ]
   end
 end
 # vim: ts=2 sw=2:

data/lib/bel/quoting.rb

@@ -0,0 +1,29 @@
+module BEL
+  module Quoting
+
+    NonWordMatcher = Regexp.compile(/[^0-9a-zA-Z_]/)
+    KeywordMatcher = Regexp.compile(/^(SET|DEFINE|a|g|p|r|m)$/)
+
+    def ensure_quotes identifier
+      return "" unless identifier
+      identifier.to_s.gsub! '"', '\"'
+      if quotes_required? identifier
+        %Q{"#{identifier}"}
+      else
+        identifier
+      end
+    end
+
+    def always_quote identifier
+      return "" unless identifier
+      identifier.to_s.gsub! '"', '\"'
+      %Q("#{identifier}")
+    end
+
+    def quotes_required? identifier
+      [NonWordMatcher, KeywordMatcher].any? { |m| m.match identifier }
+    end
+  end
+end
+# vim: ts=2 sw=2:
+# encoding: utf-8

data/lib/bel/rdf.rb

@@ -0,0 +1,314 @@
+# vim: ts=2 sw=2:
+# Defines the RDF vocabulary for BEL structures.
+
+unless BEL::Features.rdf_support?
+  # rdf and addressable are required
+  raise RuntimeError, %Q{BEL::RDF is not supported.
+The rdf and addressable gems are required.
+
+Install the gems:
+      gem install rdf
+      gem install addressable
+      gem install uuid}
+end
+
+require 'rdf'
+require 'addressable/uri'
+require 'uuid'
+
+# rename rdf module to avoid conflict within BEL::RDF
+RUBYRDF = RDF
+
+module BEL
+  module RDF
+
+    # uri prefixes
+    BELR    = RUBYRDF::Vocabulary.new('http://www.openbel.org/bel/')
+    BELV    = RUBYRDF::Vocabulary.new('http://www.openbel.org/vocabulary/')
+    PUBMED  = RUBYRDF::Vocabulary.new('http://bio2rdf.org/pubmed:')
+    RDF     = RUBYRDF
+    RDFS    = RUBYRDF::RDFS
+
+    # annotations
+    Anatomy       = RUBYRDF::Vocabulary.new('http://www.openbel.org/bel/annotation/anatomy/')
+    Cell          = RUBYRDF::Vocabulary.new('http://www.openbel.org/bel/annotation/cell/')
+    CellLine      = RUBYRDF::Vocabulary.new('http://www.openbel.org/bel/annotation/cell-line/')
+    CellStructure = RUBYRDF::Vocabulary.new('http://www.openbel.org/bel/annotation/cell-structure/')
+    Disease       = RUBYRDF::Vocabulary.new('http://www.openbel.org/bel/annotation/disease/')
+    MeSHAnatomy   = RUBYRDF::Vocabulary.new('http://www.openbel.org/bel/annotation/mesh-anatomy/')
+    MeSHDisease   = RUBYRDF::Vocabulary.new('http://www.openbel.org/bel/annotation/mesh-diseases/')
+    Species       = RUBYRDF::Vocabulary.new('http://www.openbel.org/bel/annotation/species-taxonomy-id/')
+
+    # maps outer function to bel/vocabulary class
+    FUNCTION_TYPE = {
+      a: BELV.Abundance,
+      g: BELV.GeneAbundance,
+      p: BELV.ProteinAbundance,
+      r: BELV.RNAAbundance,
+      m: BELV.microRNAAbundance,
+      complex: BELV.ComplexAbundance,
+      composite: BELV.CompositeAbundance,
+      bp: BELV.BiologicalProcess,
+      path: BELV.Pathology,
+      rxn: BELV.Reaction,
+      tloc: BELV.Translocation,
+      sec: BELV.CellSecretion,
+      deg: BELV.Degradation,
+      cat: BELV.AbundanceActivity,
+      chap: BELV.AbundanceActivity,
+      gtp: BELV.AbundanceActivity,
+      kin: BELV.AbundanceActivity,
+      act: BELV.AbundanceActivity,
+      pep: BELV.AbundanceActivity,
+      phos: BELV.AbundanceActivity,
+      ribo: BELV.AbundanceActivity,
+      tscript: BELV.AbundanceActivity,
+      tport: BELV.AbundanceActivity
+    }
+
+    RELATIONSHIP_TYPE = {
+        'association'            => BELV.Association,
+        '--'                     => BELV.Association,
+        'biomarkerFor'           => BELV.BiomarkerFor,
+        'causesNoChange'         => BELV.CausesNoChange,
+        'decreases'              => BELV.Decreases,
+        '-|'                     => BELV.Decreases,
+        'directlyDecreases'      => BELV.DirectlyDecreases,
+        '=|'                     => BELV.DirectlyDecreases,
+        'directlyIncreases'      => BELV.DirectlyIncreases,
+        '=>'                     => BELV.DirectlyIncreases,
+        'hasComponent'           => BELV.HasComponent,
+        'hasMember'              => BELV.HasMember,
+        'increases'              => BELV.Increases,
+        '->'                     => BELV.Increases,
+        'isA'                    => BELV.IsA,
+        'negativeCorrelation'    => BELV.NegativeCorrelation,
+        'positiveCorrelation'    => BELV.PositiveCorrelation,
+        'prognosticBiomarkerFor' => BELV.PrognosticBiomarkerFor,
+        'rateLimitingStepOf'     => BELV.RateLimitingStepOf,
+        'subProcessOf'           => BELV.SubProcessOf,
+        ':>'                     => BELV.TranscribedTo,
+        '>>'                     => BELV.TranslatedTo,
+
+        # Supported by schema
+        # 'actsIn'               => BELV.ActsIn, # (BELV.hasChild)
+
+        # Unsupported in schema
+        #'analogous'              => BELV.Analogous,
+        #'hasModification'        => BELV.HasModification,
+        #'hasProduct'             => BELV.HasProduct,
+        #'hasVariant'             => BELV.HasVariant,
+        #'includes'               => BELV.Includes,
+        #'orthologous'            => BELV.Orthologous,
+        #'reactantIn'             => BELV.ReactantIn,
+        #'transcribedTo'          => BELV.TranscribedTo,
+        #'translatedTo'           => BELV.TranslatedTo,
+        #'translocates'           => BELV.Translocates,
+
+        # Macro statements - TODO needs parser AST translation
+        #'hasComponents'          => BELV.HasComponents,
+        #'hasMembers'             => BELV.HasMembers,
+    }
+
+    RELATIONSHIP_CLASSIFICATION = {
+        :'association'            => BELV.CorrelativeRelationship,
+        :'--'                     => BELV.CorrelativeRelationship,
+        :'biomarkerFor'           => BELV.BiomarkerFor,
+        :'causesNoChange'         => BELV.CausesNoChange,
+        :'decreases'              => BELV.Decreases,
+        :'-|'                     => BELV.Decreases,
+        :'directlyDecreases'      => BELV.DirectlyDecreases,
+        :'=|'                     => BELV.DirectlyDecreases,
+        :'directlyIncreases'      => BELV.DirectlyIncreases,
+        :'=>'                     => BELV.DirectlyIncreases,
+        :'hasComponent'           => BELV.HasComponent,
+        :'hasMember'              => BELV.HasMember,
+        :'increases'              => BELV.Increases,
+        :'->'                     => BELV.Increases,
+        :'isA'                    => BELV.IsA,
+        :'negativeCorrelation'    => BELV.NegativeCorrelation,
+        :'positiveCorrelation'    => BELV.PositiveCorrelation,
+        :'prognosticBiomarkerFor' => BELV.PrognosticBiomarkerFor,
+        :'rateLimitingStepOf'     => BELV.RateLimitingStepOf,
+        :'subProcessOf'           => BELV.SubProcessOf
+    }
+
+    ACTIVITY_TYPE = {
+      cat: BELV.Catalytic,
+      chap: BELV.Chaperone,
+      gtp: BELV.GtpBound,
+      kin: BELV.Kinase,
+      act: BELV.Activity,
+      pep: BELV.Peptidase,
+      phos: BELV.Phosphatase,
+      ribo: BELV.Ribosylase,
+      tscript: BELV.Transcription,
+      tport: BELV.Transport
+    }
+
+    # maps modification types to bel/vocabulary class
+    MODIFICATION_TYPE = {
+      'P,S' => BELV.PhosphorylationSerine,
+      'P,T' => BELV.PhosphorylationThreonine,
+      'P,Y' => BELV.PhosphorylationTyrosine,
+      'A'   => BELV.Acetylation,
+      'F'   => BELV.Farnesylation,
+      'G'   => BELV.Glycosylation,
+      'H'   => BELV.Hydroxylation,
+      'M'   => BELV.Methylation,
+      'P'   => BELV.Phosphorylation,
+      'R'   => BELV.Ribosylation,
+      'S'   => BELV.Sumoylation,
+      'U'   => BELV.Ubiquitination
+    }
+
+    # protein variant
+    PROTEIN_VARIANT = [:fus, :fusion, :sub, :substitution, :trunc, :truncation]
+
+    def self.vocabulary_rdf
+      [
+        # Classes
+          # Concept - Annotations
+          [BELV.AnnotationConcept, RDF::RDFS.subClassOf, RDF::SKOS.Concept],
+          [BELV.AnnotationConceptScheme, RDF::RDFS.subClassOf, RDF::SKOS.ConceptScheme],
+          # Concept - Namespaces
+          [BELV.AbundanceConcept, RDF::RDFS.subClassOf, BELV.NamespaceConcept],
+          [BELV.BiologicalProcessConcept, RDF::RDFS.subClassOf, BELV.NamespaceConcept],
+          [BELV.ComplexConcept, RDF::RDFS.subClassOf, BELV.AbundanceConcept],
+          [BELV.GeneConcept, RDF::RDFS.subClassOf, BELV.AbundanceConcept],
+          [BELV.MicroRNAConcept, RDF::RDFS.subClassOf, BELV.RNAConcept],
+          [BELV.NamespaceConceptScheme, RDF::RDFS.subClassOf, RDF::SKOS.ConceptScheme],
+          [BELV.NamespaceConcept, RDF::RDFS.subClassOf, RDF::SKOS.Concept],
+          [BELV.ProteinConcept, RDF::RDFS.subClassOf, BELV.AbundanceConcept],
+          [BELV.RNAConcept, RDF::RDFS.subClassOf, BELV.AbundanceConcept],
+          [BELV.PathologyConcept, RDF::RDFS.subClassOf, BELV.BiologicalProcessConcept],
+          # BEL Language
+          [BELV.Abundance, RDF.type, RDF::RDFS.Class],
+          [BELV.Activity, RDF.type, RDF::RDFS.Class],
+          [BELV.Evidence, RDF.type, RDF::RDFS.Class],
+          [BELV.Modification, RDF.type, RDF::RDFS.Class],
+          [BELV.Relationship, RDF.type, RDF::RDFS.Class],
+          [BELV.Statement, RDF.type, RDF::RDFS.Class],
+          [BELV.Term, RDF.type, RDF::RDFS.Class],
+          # Relationships
+          [BELV.Association, RDF::RDFS.subClassOf, BELV.CorrelativeRelationship],
+          [BELV.BiomarkerFor, RDF::RDFS.subClassOf, BELV.Relationship],
+          [BELV.CausesNoChange, RDF::RDFS.subClassOf, BELV.CausalRelationship],
+          [BELV.CausalRelationship, RDF::RDFS.subClassOf, BELV.Relationship],
+          [BELV.CorrelativeRelationship, RDF::RDFS.subClassOf, BELV.Relationship],
+          [BELV.Decreases, RDF::RDFS.subClassOf, BELV.CausalRelationship],
+          [BELV.Decreases, RDF::RDFS.subClassOf, BELV.NegativeRelationship],
+          [BELV.DirectlyDecreases, RDF::RDFS.subClassOf, BELV.CausalRelationship],
+          [BELV.DirectlyDecreases, RDF::RDFS.subClassOf, BELV.NegativeRelationship],
+          [BELV.DirectlyDecreases, RDF::RDFS.subClassOf, BELV.DirectRelationship],
+          [BELV.DirectlyDecreases, RDF::RDFS.subClassOf, BELV.Decreases],
+          [BELV.DirectlyIncreases, RDF::RDFS.subClassOf, BELV.CausalRelationship],
+          [BELV.DirectlyIncreases, RDF::RDFS.subClassOf, BELV.PositiveRelationship],
+          [BELV.DirectlyIncreases, RDF::RDFS.subClassOf, BELV.DirectRelationship],
+          [BELV.DirectlyIncreases, RDF::RDFS.subClassOf, BELV.Increases],
+          [BELV.DirectRelationship, RDF::RDFS.subClassOf, BELV.Relationship],
+          [BELV.HasComponent, RDF::RDFS.subClassOf, BELV.MembershipRelationship],
+          [BELV.HasMember, RDF::RDFS.subClassOf, BELV.MembershipRelationship],
+          [BELV.Increases, RDF::RDFS.subClassOf, BELV.CausalRelationship],
+          [BELV.Increases, RDF::RDFS.subClassOf, BELV.PositiveRelationship],
+          [BELV.IsA, RDF::RDFS.subClassOf, BELV.MembershipRelationship],
+          [BELV.MembershipRelationship, RDF::RDFS.subClassOf, BELV.Relationship],
+          [BELV.NegativeCorrelation, RDF::RDFS.subClassOf, BELV.CorrelativeRelationship],
+          [BELV.NegativeCorrelation, RDF::RDFS.subClassOf, BELV.NegativeRelationship],
+          [BELV.NegativeRelationship, RDF::RDFS.subClassOf, BELV.Relationship],
+          [BELV.PositiveCorrelation, RDF::RDFS.subClassOf, BELV.CorrelativeRelationship],
+          [BELV.PositiveCorrelation, RDF::RDFS.subClassOf, BELV.PositiveRelationship],
+          [BELV.PositiveRelationship, RDF::RDFS.subClassOf, BELV.Relationship],
+          [BELV.PrognosticBiomarkerFor, RDF::RDFS.subClassOf, BELV.BiomarkerFor],
+          [BELV.RateLimitingStepOf, RDF::RDFS.subClassOf, BELV.Increases],
+          [BELV.RateLimitingStepOf, RDF::RDFS.subClassOf, BELV.CausalRelationship],
+          [BELV.RateLimitingStepOf, RDF::RDFS.subClassOf, BELV.SubProcessOf],
+          [BELV.SubProcessOf, RDF::RDFS.subClassOf, BELV.MembershipRelationship],
+          # Abundances
+          [BELV.AbundanceActivity, RDF::RDFS.subClassOf, BELV.Process],
+          [BELV.BiologicalProcess, RDF::RDFS.subClassOf, BELV.Process],
+          [BELV.CellSecretion, RDF::RDFS.subClassOf, BELV.Translocation],
+          [BELV.ComplexAbundance, RDF::RDFS.subClassOf, BELV.Abundance],
+          [BELV.CompositeAbundance, RDF::RDFS.subClassOf, BELV.Abundance],
+          [BELV.Degradation, RDF::RDFS.subClassOf, BELV.Transformation],
+          [BELV.GeneAbundance, RDF::RDFS.subClassOf, BELV.Abundance],
+          [BELV.MicroRNAAbundance, RDF::RDFS.subClassOf, BELV.Abundance],
+          [BELV.ModifiedProteinAbundance, RDF::RDFS.subClassOf, BELV.ProteinAbundance],
+          [BELV.Pathology, RDF::RDFS.subClassOf, BELV.BiologicalProcess],
+          [BELV.Process, RDF.type, RDF::RDFS.Class],
+          [BELV.ProteinAbundance, RDF::RDFS.subClassOf, BELV.Abundance],
+          [BELV.ProteinVariantAbundance, RDF::RDFS.subClassOf, BELV.ProteinAbundance],
+          [BELV.Reaction, RDF::RDFS.subClassOf, BELV.Transformation],
+          [BELV.RNAAbundance, RDF::RDFS.subClassOf, BELV.Abundance],
+          [BELV.Transformation, RDF::RDFS.subClassOf, BELV.Process],
+          [BELV.Translocation, RDF::RDFS.subClassOf, BELV.Transformation],
+          # Activities
+          [BELV.Activity, RDF::RDFS.subClassOf, BELV.Activity],
+          [BELV.Catalytic, RDF::RDFS.subClassOf, BELV.Activity],
+          [BELV.Chaperone, RDF::RDFS.subClassOf, BELV.Activity],
+          [BELV.GtpBound, RDF::RDFS.subClassOf, BELV.Activity],
+          [BELV.Kinase, RDF::RDFS.subClassOf, BELV.Activity],
+          [BELV.Peptidase, RDF::RDFS.subClassOf, BELV.Activity],
+          [BELV.Phosphatase, RDF::RDFS.subClassOf, BELV.Activity],
+          [BELV.Ribosylase, RDF::RDFS.subClassOf, BELV.Activity],
+          [BELV.Transcription, RDF::RDFS.subClassOf, BELV.Activity],
+          [BELV.Transport, RDF::RDFS.subClassOf, BELV.Activity],
+          # Modifications
+          [BELV.Acetylation, RDF::RDFS.subClassOf, BELV.Modification],
+          [BELV.Farnesylation, RDF::RDFS.subClassOf, BELV.Modification],
+          [BELV.Glycosylation, RDF::RDFS.subClassOf, BELV.Modification],
+          [BELV.Hydroxylation, RDF::RDFS.subClassOf, BELV.Modification],
+          [BELV.Methylation, RDF::RDFS.subClassOf, BELV.Modification],
+          [BELV.Phosphorylation, RDF::RDFS.subClassOf, BELV.Modification],
+          [BELV.Ribosylation, RDF::RDFS.subClassOf, BELV.Modification],
+          [BELV.Sumoylation, RDF::RDFS.subClassOf, BELV.Modification],
+          [BELV.Ubiquitination, RDF::RDFS.subClassOf, BELV.Modification],
+          [BELV.PhosphorylationSerine, RDF::RDFS.subClassOf, BELV.Phosphorylation],
+          [BELV.PhosphorylationTyrosine, RDF::RDFS.subClassOf, BELV.Phosphorylation],
+          [BELV.PhosphorylationThreonine, RDF::RDFS.subClassOf, BELV.Phosphorylation],
+
+        # Properties
+          # Term
+          [BELV.hasActivityType, RDF.type, RDF.Property],
+          [BELV.hasActivityType, RDF::RDFS.range, BELV.Activity],
+          [BELV.hasActivityType, RDF::RDFS.domain, BELV.Term],
+          [BELV.hasChild, RDF.type, RDF.Property],
+          [BELV.hasChild, RDF::RDFS.range, BELV.Term],
+          [BELV.hasChild, RDF::RDFS.domain, BELV.Term],
+          [BELV.hasConcept, RDF.type, RDF.Property],
+          [BELV.hasConcept, RDF::RDFS.range, BELV.NamespaceConcept],
+          [BELV.hasConcept, RDF::RDFS.domain, BELV.Term],
+          [BELV.hasModificationPosition, RDF.type, RDF.Property],
+          [BELV.hasModificationPosition, RDF::RDFS.range, RDF::XSD.integer],
+          [BELV.hasModificationPosition, RDF::RDFS.domain, BELV.Term],
+          [BELV.hasModificationType, RDF.type, RDF.Property],
+          [BELV.hasModificationType, RDF::RDFS.range, BELV.Activity],
+          [BELV.hasModificationType, RDF::RDFS.domain, BELV.Term],
+          # Statement
+          [BELV.hasEvidence, RDF.type, RDF.Property],
+          [BELV.hasEvidence, RDF::RDFS.range, BELV.Evidence],
+          [BELV.hasEvidence, RDF::RDFS.domain, BELV.Statement],
+          [BELV.hasObject, RDF::RDFS.subPropertyOf, BELV.hasChild],
+          [BELV.hasObject, RDF::RDFS.range, BELV.Term],
+          [BELV.hasObject, RDF::RDFS.domain, BELV.Statement],
+          [BELV.hasRelationship, RDF.type, RDF.Property],
+          [BELV.hasRelationship, RDF::RDFS.range, BELV.Relationship],
+          [BELV.hasRelationship, RDF::RDFS.domain, BELV.Statement],
+          [BELV.hasSubject, RDF::RDFS.subPropertyOf, BELV.hasChild],
+          [BELV.hasSubject, RDF::RDFS.range, BELV.Term],
+          [BELV.hasSubject, RDF::RDFS.domain, BELV.Statement],
+          # Evidence
+          [BELV.hasAnnotation, RDF.type, RDF.Property],
+          [BELV.hasAnnotation, RDF::RDFS.range, BELV.AnnotationConcept],
+          [BELV.hasAnnotation, RDF::RDFS.domain, BELV.Evidence],
+          [BELV.hasCitation, RDF.type, RDF.Property],
+          [BELV.hasCitation, RDF::RDFS.domain, BELV.Evidence],
+          [BELV.hasEvidenceText, RDF::RDFS.range, RDF::XSD.string],
+          [BELV.hasEvidenceText, RDF::RDFS.domain, BELV.Evidence],
+          [BELV.hasStatement, RDF.type, RDF.Property],
+          [BELV.hasStatement, RDF::RDFS.range, BELV.Statement],
+          [BELV.hasStatement, RDF::RDFS.domain, BELV.Evidence]
+      ]
+    end
+  end
+end