bel 0.7.0 → 1.0.0

data/lib/bel/translate.rb

@@ -10,7 +10,7 @@ module BEL
     # mixin.
     module ClassMethods
 
-      # Return a stream of {::BEL::Model::Evidence} objects for the input.
+      # Return a stream of {::BEL::Nanopub::Nanopub} objects for the input.
       #
       # @param  [IO]                     input        the IO to read from
       # @param  [Symbol]                 input_format the symbol that can be
@@ -18,18 +18,18 @@ module BEL
       #         +input+
       # @param  [Hash{Symbol => Object}] options
       # @return [#each]                  an object that responds to +each+ and
-      #         provides {::BEL::Model::Evidence} objects
-      def evidence(input, input_format, options = {})
+      #         provides {::BEL::Nanopub::Nanopub} objects
+      def nanopub(input, input_format, options = {})
         prepared_input = process_input(input)
 
         in_translator  = self.translator(input_format) or
           raise TranslateError.new(input_format)
 
-        in_translator.read(prepared_input)
+        in_translator.read(prepared_input, options)
       end
 
       # Translate from one file format to another using
-      # {::BEL::Model::Evidence} as a shared model. The translation is written
+      # {::BEL::Nanopub::Nanopub} as a shared model. The translation is written
       # to the IO +writer+ directly.
       #
       # @param  [IO]                     input         the IO to read from
@@ -49,8 +49,8 @@ module BEL
         out_translator = self.translator(output_format, options) or
           raise TranslateError.new(output_format)
 
-        evidence = in_translator.read(prepared_input)
-        out_translator.write(evidence, writer, options)
+        nanopub = in_translator.read(prepared_input, options)
+        out_translator.write(nanopub, writer, options)
         writer
       end
 

data/lib/bel/translator.rb

@@ -1,29 +1,29 @@
 module BEL
 
   # The Translator module defines a plugin that reads a specific document
-  # format into BEL evidence and writes BEL evidence back to this document
+  # format into BEL nanopubs and writes BEL nanopubs back to this document
   # format.
   #
   # - Read
   #   - {#read}:            read the input format and parse to
-  #     {::BEL::Model::Evidence} objects
+  #     {::BEL::Nanopub::Nanopub} objects
   # - Write
-  #   - {#write}:           write {::BEL::Model::Evidence} objects to the
+  #   - {#write}:           write {::BEL::Nanopub::Nanopub} objects to the
   #     output format
   #
-  # @example Create a translator for conversion of YAML <-> BEL Evidence.
+  # @example Create a translator for conversion of YAML <-> BEL nanopub.
   #   module Translator
   #
   #     include ::BEL::Translator
   #
   #     def read(data, options = {})
   #       objects = YAML.load(data)
-  #       # map objects to BEL evidence
+  #       # map objects to BEL nanopub
   #       # return enumerator
   #     end
   #
   #     def write(data, writer = nil, options = {})
-  #       # map BEL evidence to YAML objects
+  #       # map BEL nanopub to YAML objects
   #       YAML.dump(data)
   #     end
   #   end
@@ -80,20 +80,20 @@ module BEL
       :module => BEL::Translator::Plugins
     )
 
-    # Read BEL evidence from this translator's supported file format.
+    # Read BEL nanopubs from this translator's supported file format.
     #
     # @param  [IO, String]             data the data to read
     # @param  [Hash{Symbol => Object}] options
     # @return [#each]                  an object that responds to +each+ and
-    #         provides {::BEL::Model::Evidence} objects
+    #         provides {::BEL::Nanopub::Nanopub} objects
     def read(data, options = {})
       raise NotImplementedError.new("#{__method__} is not implemented.")
     end
 
-    # Writes BEL evidence +data+ to the provided IO +writer+.
+    # Writes BEL nanopubs to the provided IO +writer+.
     #
     # @param  [#each]                  data an object that responds to +each+ and
-    #         provides {::BEL::Model::Evidence} objects
+    #         provides {::BEL::Nanopub::Nanopub} objects
     # @param  [IO]                     writer an IO to write to
     # @param  [Hash{Symbol => Object}] options
     # @return [IO]                     the IO that was written to

data/lib/bel/translator/plugins/bnj.rb

@@ -0,0 +1,37 @@
+module BEL::Translator::Plugins
+
+  module Bnj
+
+    ID            = :bnj
+    NAME          = 'BEL Nanopub JSON Translator'
+    DESCRIPTION   = 'A translator that can read/write BEL nanopubs to BNJ.'
+    MEDIA_TYPES   = %i(application/json)
+    EXTENSIONS    = %i(json)
+    NANOPUB_ROOT  = :nanopub
+
+    def self.create_translator(options = {})
+      require_relative 'bnj/translator'
+      BnjTranslator.new
+    end
+    
+    def self.id
+      ID
+    end
+
+    def self.name
+      NAME
+    end
+
+    def self.description
+      DESCRIPTION
+    end
+
+    def self.media_types
+      MEDIA_TYPES
+    end
+
+    def self.file_extensions
+      EXTENSIONS
+    end
+  end
+end

data/lib/bel/translator/plugins/{json_evidence → bnj}/translator.rb

@@ -3,15 +3,15 @@ require 'bel/json'
 
 module BEL::Translator::Plugins
 
-  module JsonEvidence
+  module Bnj
 
-    class JsonEvidenceTranslator
+    class BnjTranslator
 
       include ::BEL::Translator
 
       def read(data, options = {})
         ::BEL::JSON.read(data, options).lazy.select { |obj|
-          obj.include?(:evidence)
+          obj.include?(Bnj::NANOPUB_ROOT)
         }.map { |json_obj|
           unwrap(json_obj)
         }
@@ -21,20 +21,20 @@ module BEL::Translator::Plugins
         json_strings = Enumerator.new { |yielder|
           yielder << '['
           begin
-            evidence_enum = objects.each
+            nanopub_enum = objects.each
 
-            # write first evidence object
-            evidence = evidence_enum.next
-            yielder << ::BEL::JSON.write(wrap(evidence), nil)
+            # write first nanopub object
+            nanopub = nanopub_enum.next
+            yielder << ::BEL::JSON.write(wrap(nanopub), nil)
 
-            # each successive evidence starts with a comma
+            # each successive nanopub starts with a comma
             while true
-              evidence = evidence_enum.next
+              nanopub = nanopub_enum.next
               yielder << ','
-              yielder << ::BEL::JSON.write(wrap(evidence), nil)
+              yielder << ::BEL::JSON.write(wrap(nanopub), nil)
             end
           rescue StopIteration
-            # end of evidence hashes
+            # end of nanopub hashes
           end
           yielder << ']'
         }
@@ -66,13 +66,13 @@ module BEL::Translator::Plugins
         writer << ']'
       end
 
-      def wrap(evidence)
-        hash = evidence.to_h
+      def wrap(nanopub)
+        hash = nanopub.to_h
         {
-          EVIDENCE_ROOT => {
+          NANOPUB_ROOT => {
             :bel_statement      => hash[:bel_statement].to_s,
             :citation           => hash[:citation],
-            :summary_text       => escape_newlines(hash[:summary_text]),
+            :support            => escape_newlines(hash[:support]),
             :experiment_context => hash[:experiment_context],
             :references         => hash[:references],
             :metadata           => hash[:metadata].to_a
@@ -81,28 +81,11 @@ module BEL::Translator::Plugins
       end
 
       def unwrap(hash)
-        evidence_hash          = hash[EVIDENCE_ROOT]
-        evidence               = ::BEL::Model::Evidence.create(evidence_hash)
-
-        evidence.bel_statement = parse_statement(evidence)
-        evidence
-      end
-
-      def parse_statement(evidence)
-        namespaces = evidence.references.namespaces
-        ::BEL::Script.parse(
-          "#{evidence.bel_statement}\n",
-          Hash[
-            namespaces.map { |k, v|
-              [k, ::BEL::Namespace::NamespaceDefinition.new(k, v)]
-            }
-          ]
-        ).select { |obj|
-          obj.is_a? ::BEL::Model::Statement
-        }.first
+        ::BEL::Nanopub::Nanopub.create(hash[NANOPUB_ROOT])
       end
 
       def escape_newlines(value)
+        return nil if value.nil?
         value.gsub(/\n/, "\\n").gsub(/\r/, "\\r")
       end
     end

data/lib/bel/translator/plugins/jgf.rb

@@ -4,7 +4,7 @@ module BEL::Translator::Plugins
 
     ID          = :jgf
     NAME        = 'JSON Graph Format Translator'
-    DESCRIPTION = 'A translator that can read and write evidence statements in a JSON Graph Format.'
+    DESCRIPTION = 'A translator that can read/write BEL nanopubs to JGF.'
     MEDIA_TYPES   = %i(application/vnd.jgf+json)
     EXTENSIONS    = %i(jgf.json)
 

data/lib/bel/translator/plugins/jgf/translator.rb

@@ -28,12 +28,12 @@ module BEL::Translator::Plugins
           :edges => []
         }
 
-        objects.each do |evidence|
-          unless evidence.bel_statement.is_a?(::BEL::Model::Statement)
-            evidence.bel_statement = ::BEL::Model::Evidence.parse_statement(evidence)
+        objects.each do |nanopub|
+          unless nanopub.bel_statement.is_a?(::BEL::Nanopub::Statement)
+            nanopub.bel_statement = ::BEL::Nanopub::Nanopub.parse_statement(nanopub)
           end
 
-          stmt    = evidence.bel_statement
+          stmt    = nanopub.bel_statement
           subject = stmt.subject.to_bel
 
           graph[:nodes] << {
@@ -87,7 +87,7 @@ module BEL::Translator::Plugins
             rel  = 'association' unless rel
 
             bel_statement = ::BEL::Script.parse(
-              "#{source_node} #{rel} #{target_node}\n").select { |obj| obj.is_a? ::BEL::Model::Statement }.first
+              "#{source_node} #{rel} #{target_node}\n").select { |obj| obj.is_a? ::BEL::Nanopub::Statement }.first
           end
         }.compact
 
@@ -98,17 +98,17 @@ module BEL::Translator::Plugins
               ::BEL::Script.parse(
                 "#{id_nodes[id]}\n"
               ).select { |obj|
-                obj.is_a? ::BEL::Model::Statement
+                obj.is_a? ::BEL::Nanopub::Statement
               }.first
             }
           )
         end
 
-        # map statements to evidence objects
+        # map statements to nanopub objects
         bel_statements.map { |bel_statement|
           graph_name = graph[:label] || graph[:id] || 'BEL Graph'
-          metadata   = ::BEL::Model::Metadata.new
-          references = ::BEL::Model::References.new
+          metadata   = ::BEL::Nanopub::Metadata.new
+          references = ::BEL::Nanopub::References.new
 
           # establish document header
           metadata.document_header[:Name]        = graph_name
@@ -152,7 +152,7 @@ module BEL::Translator::Plugins
           end
           references.namespaces = namespaces if namespaces
 
-          ::BEL::Model::Evidence.create(
+          ::BEL::Nanopub::Nanopub.create(
             :bel_statement => bel_statement,
             :metadata      => metadata,
             :references    => references

data/lib/bel/translator/plugins/jsonld.rb

@@ -4,7 +4,7 @@ module BEL::Translator::Plugins
 
     ID          = :jsonld
     NAME        = 'JSON-LD RDF Translator'
-    DESCRIPTION = 'A translator that can read and write JSON-LD (http://json-ld.org/) for BEL evidence.'
+    DESCRIPTION = 'A translator that can read/write BEL nanopubs to JSON-LD.'
     MEDIA_TYPES = %i(application/ld+json)
     EXTENSIONS  = %i(jsonld)
 

data/lib/bel/translator/plugins/nquads.rb

@@ -4,7 +4,7 @@ module BEL::Translator::Plugins
 
     ID          = :nquads
     NAME        = 'N-quads RDF Translator'
-    DESCRIPTION = 'A translator that can read and write N-quads for BEL evidence.'
+    DESCRIPTION = 'A translator that can read/write BEL nanopubs to N-quads.'
     MEDIA_TYPES = %i(application/n-quads)
     EXTENSIONS  = %i(nq)
 

data/lib/bel/translator/plugins/ntriples.rb

@@ -4,7 +4,7 @@ module BEL::Translator::Plugins
 
     ID          = :ntriples
     NAME        = 'N-triples RDF Translator'
-    DESCRIPTION = 'A translator that can read and write N-triples for BEL evidence.'
+    DESCRIPTION = 'A translator that can read/write BEL nanopubs to N-triples.'
     MEDIA_TYPES = %i(application/n-triples)
     EXTENSIONS  = %i(nt)
 

data/lib/bel/translator/plugins/rdf/bel_schema.rb

@@ -1,13 +1,21 @@
+require 'rdf'
+require 'rdf/vocab'
+
 # Defines the RDF vocabulary for BEL structures.
 module BELRDF
 
   # uri prefixes
-  BELR    = ::RDF::Vocabulary.new('http://www.openbel.org/bel/')
-  BELV    = ::RDF::Vocabulary.new('http://www.openbel.org/vocabulary/')
-  BELE    = ::RDF::Vocabulary.new('http://www.openbel.org/evidence/')
-  PUBMED  = ::RDF::Vocabulary.new('http://bio2rdf.org/pubmed:')
-  RDF     = ::RDF
-  RDFS    = ::RDF::RDFS
+  BELR   = ::RDF::Vocabulary.new('http://www.openbel.org/bel/')
+  BELV   = ::RDF::Vocabulary.new('http://www.openbel.org/vocabulary/')
+  BELE   = ::RDF::Vocabulary.new('http://www.openbel.org/evidence/')
+  DC     = ::RDF::Vocab::DC
+  FOAF   = ::RDF::Vocab::FOAF
+  PUBMED = ::RDF::Vocabulary.new('http://bio2rdf.org/pubmed:')
+  RDF    = ::RDF
+  RDFS   = ::RDF::Vocab::RDFS
+  SKOS   = ::RDF::Vocab::SKOS
+  VOID   = ::RDF::Vocab::VOID
+  XSD    = ::RDF::Vocab::XSD
 
   # annotations
   Anatomy       = 'http://www.openbel.org/bel/annotation/anatomy/'
@@ -194,152 +202,152 @@ module BELRDF
 
   RDFS_SCHEMA = deep_freeze([
     # Classes - Annotation Concept
-    [BELV.AnnotationConcept, RDF::RDFS.subClassOf, RDF::SKOS.Concept],
-    [BELV.AnnotationConceptScheme, RDF::RDFS.subClassOf, RDF::SKOS.ConceptScheme],
+    [BELV.AnnotationConcept, RDFS.subClassOf, SKOS.Concept],
+    [BELV.AnnotationConceptScheme, RDFS.subClassOf, SKOS.ConceptScheme],
 
     # Classes - Namespace Concept
-    [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],
+    [BELV.AbundanceConcept, RDFS.subClassOf, BELV.NamespaceConcept],
+    [BELV.BiologicalProcessConcept, RDFS.subClassOf, BELV.NamespaceConcept],
+    [BELV.ComplexConcept, RDFS.subClassOf, BELV.AbundanceConcept],
+    [BELV.GeneConcept, RDFS.subClassOf, BELV.AbundanceConcept],
+    [BELV.MicroRNAConcept, RDFS.subClassOf, BELV.RNAConcept],
+    [BELV.NamespaceConceptScheme, RDFS.subClassOf, SKOS.ConceptScheme],
+    [BELV.NamespaceConcept, RDFS.subClassOf, SKOS.Concept],
+    [BELV.ProteinConcept, RDFS.subClassOf, BELV.AbundanceConcept],
+    [BELV.RNAConcept, RDFS.subClassOf, BELV.AbundanceConcept],
+    [BELV.PathologyConcept, RDFS.subClassOf, BELV.BiologicalProcessConcept],
 
     # Classes - Language Concepts
-    [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],
+    [BELV.Abundance, RDF.type, RDFS.Class],
+    [BELV.Activity, RDF.type, RDFS.Class],
+    [BELV.Nanopub, RDF.type, RDFS.Class],
+    [BELV.Modification, RDF.type, RDFS.Class],
+    [BELV.Relationship, RDF.type, RDFS.Class],
+    [BELV.Statement, RDF.type, RDFS.Class],
+    [BELV.Term, RDF.type, RDFS.Class],
 
     # Classes - 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],
+    [BELV.Association, RDFS.subClassOf, BELV.CorrelativeRelationship],
+    [BELV.BiomarkerFor, RDFS.subClassOf, BELV.Relationship],
+    [BELV.CausesNoChange, RDFS.subClassOf, BELV.CausalRelationship],
+    [BELV.CausalRelationship, RDFS.subClassOf, BELV.Relationship],
+    [BELV.CorrelativeRelationship, RDFS.subClassOf, BELV.Relationship],
+    [BELV.Decreases, RDFS.subClassOf, BELV.CausalRelationship],
+    [BELV.Decreases, RDFS.subClassOf, BELV.NegativeRelationship],
+    [BELV.DirectlyDecreases, RDFS.subClassOf, BELV.CausalRelationship],
+    [BELV.DirectlyDecreases, RDFS.subClassOf, BELV.NegativeRelationship],
+    [BELV.DirectlyDecreases, RDFS.subClassOf, BELV.DirectRelationship],
+    [BELV.DirectlyDecreases, RDFS.subClassOf, BELV.Decreases],
+    [BELV.DirectlyIncreases, RDFS.subClassOf, BELV.CausalRelationship],
+    [BELV.DirectlyIncreases, RDFS.subClassOf, BELV.PositiveRelationship],
+    [BELV.DirectlyIncreases, RDFS.subClassOf, BELV.DirectRelationship],
+    [BELV.DirectlyIncreases, RDFS.subClassOf, BELV.Increases],
+    [BELV.DirectRelationship, RDFS.subClassOf, BELV.Relationship],
+    [BELV.HasComponent, RDFS.subClassOf, BELV.MembershipRelationship],
+    [BELV.HasMember, RDFS.subClassOf, BELV.MembershipRelationship],
+    [BELV.Increases, RDFS.subClassOf, BELV.CausalRelationship],
+    [BELV.Increases, RDFS.subClassOf, BELV.PositiveRelationship],
+    [BELV.IsA, RDFS.subClassOf, BELV.MembershipRelationship],
+    [BELV.MembershipRelationship, RDFS.subClassOf, BELV.Relationship],
+    [BELV.NegativeCorrelation, RDFS.subClassOf, BELV.CorrelativeRelationship],
+    [BELV.NegativeCorrelation, RDFS.subClassOf, BELV.NegativeRelationship],
+    [BELV.NegativeRelationship, RDFS.subClassOf, BELV.Relationship],
+    [BELV.PositiveCorrelation, RDFS.subClassOf, BELV.CorrelativeRelationship],
+    [BELV.PositiveCorrelation, RDFS.subClassOf, BELV.PositiveRelationship],
+    [BELV.PositiveRelationship, RDFS.subClassOf, BELV.Relationship],
+    [BELV.PrognosticBiomarkerFor, RDFS.subClassOf, BELV.BiomarkerFor],
+    [BELV.RateLimitingStepOf, RDFS.subClassOf, BELV.Increases],
+    [BELV.RateLimitingStepOf, RDFS.subClassOf, BELV.CausalRelationship],
+    [BELV.RateLimitingStepOf, RDFS.subClassOf, BELV.SubProcessOf],
+    [BELV.SubProcessOf, RDFS.subClassOf, BELV.MembershipRelationship],
 
     # Classes - 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],
+    [BELV.AbundanceActivity, RDFS.subClassOf, BELV.Process],
+    [BELV.BiologicalProcess, RDFS.subClassOf, BELV.Process],
+    [BELV.CellSecretion, RDFS.subClassOf, BELV.Translocation],
+    [BELV.ComplexAbundance, RDFS.subClassOf, BELV.Abundance],
+    [BELV.CompositeAbundance, RDFS.subClassOf, BELV.Abundance],
+    [BELV.Degradation, RDFS.subClassOf, BELV.Transformation],
+    [BELV.GeneAbundance, RDFS.subClassOf, BELV.Abundance],
+    [BELV.MicroRNAAbundance, RDFS.subClassOf, BELV.Abundance],
+    [BELV.ModifiedProteinAbundance, RDFS.subClassOf, BELV.ProteinAbundance],
+    [BELV.Pathology, RDFS.subClassOf, BELV.BiologicalProcess],
+    [BELV.Process, RDF.type, RDFS.Class],
+    [BELV.ProteinAbundance, RDFS.subClassOf, BELV.Abundance],
+    [BELV.ProteinVariantAbundance, RDFS.subClassOf, BELV.ProteinAbundance],
+    [BELV.Reaction, RDFS.subClassOf, BELV.Transformation],
+    [BELV.RNAAbundance, RDFS.subClassOf, BELV.Abundance],
+    [BELV.Transformation, RDFS.subClassOf, BELV.Process],
+    [BELV.Translocation, RDFS.subClassOf, BELV.Transformation],
 
     # Classes - 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],
+    [BELV.Activity, RDFS.subClassOf, BELV.Activity],
+    [BELV.Catalytic, RDFS.subClassOf, BELV.Activity],
+    [BELV.Chaperone, RDFS.subClassOf, BELV.Activity],
+    [BELV.GtpBound, RDFS.subClassOf, BELV.Activity],
+    [BELV.Kinase, RDFS.subClassOf, BELV.Activity],
+    [BELV.Peptidase, RDFS.subClassOf, BELV.Activity],
+    [BELV.Phosphatase, RDFS.subClassOf, BELV.Activity],
+    [BELV.Ribosylase, RDFS.subClassOf, BELV.Activity],
+    [BELV.Transcription, RDFS.subClassOf, BELV.Activity],
+    [BELV.Transport, RDFS.subClassOf, BELV.Activity],
 
     # Classes - 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],
+    [BELV.Acetylation, RDFS.subClassOf, BELV.Modification],
+    [BELV.Farnesylation, RDFS.subClassOf, BELV.Modification],
+    [BELV.Glycosylation, RDFS.subClassOf, BELV.Modification],
+    [BELV.Hydroxylation, RDFS.subClassOf, BELV.Modification],
+    [BELV.Methylation, RDFS.subClassOf, BELV.Modification],
+    [BELV.Phosphorylation, RDFS.subClassOf, BELV.Modification],
+    [BELV.Ribosylation, RDFS.subClassOf, BELV.Modification],
+    [BELV.Sumoylation, RDFS.subClassOf, BELV.Modification],
+    [BELV.Ubiquitination, RDFS.subClassOf, BELV.Modification],
+    [BELV.PhosphorylationSerine, RDFS.subClassOf, BELV.Phosphorylation],
+    [BELV.PhosphorylationTyrosine, RDFS.subClassOf, BELV.Phosphorylation],
+    [BELV.PhosphorylationThreonine, RDFS.subClassOf, BELV.Phosphorylation],
 
     # Properties - BEL Term
     [BELV.hasActivityType, RDF.type, RDF.Property],
-    [BELV.hasActivityType, RDF::RDFS.range, BELV.Activity],
-    [BELV.hasActivityType, RDF::RDFS.domain, BELV.Term],
+    [BELV.hasActivityType, RDFS.range, BELV.Activity],
+    [BELV.hasActivityType, 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.hasChild, RDFS.range, BELV.Term],
+    [BELV.hasChild, 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.hasConcept, RDFS.range, BELV.NamespaceConcept],
+    [BELV.hasConcept, 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.hasModificationPosition, RDFS.range, XSD.integer],
+    [BELV.hasModificationPosition, RDFS.domain, BELV.Term],
     [BELV.hasModificationType, RDF.type, RDF.Property],
-    [BELV.hasModificationType, RDF::RDFS.range, BELV.Activity],
-    [BELV.hasModificationType, RDF::RDFS.domain, BELV.Term],
+    [BELV.hasModificationType, RDFS.range, BELV.Activity],
+    [BELV.hasModificationType, RDFS.domain, BELV.Term],
 
     # Properties - BEL 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.hasNanopub, RDF.type, RDF.Property],
+    [BELV.hasNanopub, RDFS.range, BELV.Nanopub],
+    [BELV.hasNanopub, RDFS.domain, BELV.Statement],
+    [BELV.hasObject, RDFS.subPropertyOf, BELV.hasChild],
+    [BELV.hasObject, RDFS.range, BELV.Term],
+    [BELV.hasObject, 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],
+    [BELV.hasRelationship, RDFS.range, BELV.Relationship],
+    [BELV.hasRelationship, RDFS.domain, BELV.Statement],
+    [BELV.hasSubject, RDFS.subPropertyOf, BELV.hasChild],
+    [BELV.hasSubject, RDFS.range, BELV.Term],
+    [BELV.hasSubject, RDFS.domain, BELV.Statement],
 
-    # Properties - Evidence
+    # Properties - Nanopub
     [BELV.hasAnnotation, RDF.type, RDF.Property],
-    [BELV.hasAnnotation, RDF::RDFS.range, BELV.AnnotationConcept],
-    [BELV.hasAnnotation, RDF::RDFS.domain, BELV.Evidence],
+    [BELV.hasAnnotation, RDFS.range, BELV.AnnotationConcept],
+    [BELV.hasAnnotation, RDFS.domain, BELV.Nanopub],
     [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.hasCitation, RDFS.domain, BELV.Nanopub],
+    [BELV.hasNanopubText, RDFS.range, XSD.string],
+    [BELV.hasNanopubText, RDFS.domain, BELV.Nanopub],
     [BELV.hasStatement, RDF.type, RDF.Property],
-    [BELV.hasStatement, RDF::RDFS.range, BELV.Statement],
-    [BELV.hasStatement, RDF::RDFS.domain, BELV.Evidence]
+    [BELV.hasStatement, RDFS.range, BELV.Statement],
+    [BELV.hasStatement, RDFS.domain, BELV.Nanopub]
   ])
 
   def self.vocabulary_rdf