bel 0.7.0 → 1.0.0

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

@@ -24,7 +24,7 @@ module BELRDF
     end
 
     def read(data, options = {})
-      Reader::BufferedEvidenceYielder.new(data, @format)
+      Reader::BufferedNanopubYielder.new(data, @format)
     end
 
     def write(objects, io = StringIO.new, options = {})
@@ -61,10 +61,10 @@ module BELRDF
           yielder << RDF::Statement.new(*schema_statement)
         end
 
-        # enumerate BEL evidence
-        objects.each do |evidence|
+        # enumerate BEL nanopubs
+        objects.each do |nanopub|
           if void_dataset_uri && !wrote_dataset
-            void_dataset_triples = evidence.to_void_dataset(void_dataset_uri)
+            void_dataset_triples = nanopub.to_void_dataset(void_dataset_uri)
             if void_dataset_triples && void_dataset_triples.respond_to?(:each)
               void_dataset_triples.each do |void_triple|
                 yielder << void_triple
@@ -73,7 +73,7 @@ module BELRDF
             wrote_dataset = true
           end
 
-          evidence_uri, statements = evidence.to_rdf
+          nanopub_uri, statements = nanopub.to_rdf
           statements.each do |statement|
             yielder << statement
           end
@@ -82,7 +82,7 @@ module BELRDF
             yielder << RDF::Statement.new(
               void_dataset_uri,
               RDF::DC.hasPart,
-              evidence_uri
+              nanopub_uri
             )
           end
         end

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

@@ -1,24 +1,25 @@
-require          'bel/evidence_model'
+require          'bel/nanopub'
+require_relative 'bel_schema'
 require_relative 'uuid'
 
 module BELRDF
 
-  # OpenClass to contribute RDF functionality to BEL Model.
+  # OpenClass to contribute RDF functionality to BEL Nanopub objects.
 
   class ::BEL::Namespace::NamespaceDefinition
 
     def to_uri
-      @rdf_uri
+      rdf_uri
     end
 
     def to_rdf_vocabulary
       uri = @rdf_uri
-      uri << '/' unless uri.end_with?('/')
+      uri << '/' if uri && !uri.end_with?('/')
       ::RDF::Vocabulary.new(uri)
     end
   end
 
-  class ::BEL::Model::Parameter
+  class ::BEL::Nanopub::Parameter
 
     CONCEPT_ENCODING = {
       :G => BELRDF::BELV.GeneConcept,
@@ -70,7 +71,7 @@ module BELRDF
     end
   end
 
-  class ::BEL::Model::Term
+  class ::BEL::Nanopub::Term
 
     def to_uri
       tid = to_s.squeeze(')').gsub(/[")\[\]]/, '').gsub(/[(:, ]/, '_')
@@ -82,7 +83,7 @@ module BELRDF
         fx = @fx.respond_to?(:short_form) ? @fx.short_form : @fx.to_s.to_sym
         if [:p, :proteinAbundance].include?(fx) &&
            @arguments.find{ |x|
-             if x.is_a? ::BEL::Model::Term
+             if x.is_a? ::BEL::Nanopub::Term
                arg_fx = x.fx
                arg_fx = arg_fx.respond_to?(:short_form) ? arg_fx.short_form : arg_fx.to_s.to_sym
                [:pmod, :proteinModification].include?(arg_fx)
@@ -96,7 +97,7 @@ module BELRDF
 
         if [:p, :proteinAbundance].include?(fx) &&
            @arguments.find{ |x|
-             if x.is_a? ::BEL::Model::Term
+             if x.is_a? ::BEL::Nanopub::Term
                arg_fx = x.fx
                arg_fx = arg_fx.respond_to?(:short_form) ? arg_fx.short_form : arg_fx.to_s.to_sym
                BELRDF::PROTEIN_VARIANT.include?(arg_fx)
@@ -132,7 +133,7 @@ module BELRDF
       if [:p, :proteinAbundance].include?(fx)
         pmod =
           @arguments.find{ |x|
-            if x.is_a? ::BEL::Model::Term
+            if x.is_a? ::BEL::Nanopub::Term
               arg_fx = x.fx
               arg_fx = arg_fx.respond_to?(:short_form) ? arg_fx.short_form : arg_fx.to_s.to_sym
               [:pmod, :proteinModification].include?(arg_fx)
@@ -150,15 +151,15 @@ module BELRDF
             statements << ::RDF::Statement.new(uri, BELRDF::BELV.hasModificationPosition, last.to_i, :graph_name => graph_name)
           end
           # link root protein abundance as hasChild
-          root_param = @arguments.find{|x| x.is_a? ::BEL::Model::Parameter}
-          (root_id, root_statements) = ::BEL::Model::Term.new(:p, [root_param]).to_rdf(graph_name, remap)
+          root_param = @arguments.find{|x| x.is_a? ::BEL::Nanopub::Parameter}
+          (root_id, root_statements) = ::BEL::Nanopub::Term.new(:p, [root_param]).to_rdf(graph_name, remap)
           statements << ::RDF::Statement.new(uri, BELRDF::BELV.hasChild, root_id, :graph_name => graph_name)
           statements.concat(root_statements)
           return [uri, statements]
-        elsif @arguments.find{|x| x.is_a? ::BEL::Model::Term and BELRDF::PROTEIN_VARIANT.include? x.fx}
+        elsif @arguments.find{|x| x.is_a? ::BEL::Nanopub::Term and BELRDF::PROTEIN_VARIANT.include? x.fx}
           # link root protein abundance as hasChild
-          root_param = @arguments.find{|x| x.is_a? ::BEL::Model::Parameter}
-          (root_id, root_statements) = ::BEL::Model::Term.new(:p, [root_param]).to_rdf(graph_name, remap)
+          root_param = @arguments.find{|x| x.is_a? ::BEL::Nanopub::Parameter}
+          (root_id, root_statements) = ::BEL::Nanopub::Term.new(:p, [root_param]).to_rdf(graph_name, remap)
           statements << ::RDF::Statement.new(uri, BELRDF::BELV.hasChild, root_id, :graph_name => graph_name)
           statements.concat(root_statements)
           return [uri, statements]
@@ -167,7 +168,7 @@ module BELRDF
 
       # BELRDF::BELV.hasConcept
       @arguments.find_all{ |x|
-        x.is_a? ::BEL::Model::Parameter and x.ns != nil
+        x.is_a? ::BEL::Nanopub::Parameter and x.ns != nil
       }.each do |param|
         param_uri, encoding_statements = param.to_rdf(graph_name, remap)
         statements.concat(encoding_statements)
@@ -175,7 +176,7 @@ module BELRDF
       end
 
       # BELRDF::BELV.hasChild]
-      @arguments.find_all{|x| x.is_a? ::BEL::Model::Term}.each do |child|
+      @arguments.find_all{|x| x.is_a? ::BEL::Nanopub::Term}.each do |child|
         (child_id, child_statements) = child.to_rdf(graph_name, remap)
         statements << ::RDF::Statement.new(uri, BELRDF::BELV.hasChild, child_id, :graph_name => graph_name)
         statements.concat(child_statements)
@@ -185,7 +186,7 @@ module BELRDF
     end
   end
 
-  class ::BEL::Model::Statement
+  class ::BEL::Nanopub::Statement
 
     def to_uri
       case
@@ -267,13 +268,13 @@ module BELRDF
 
       # common statement triples
       statements << ::RDF::Statement.new(uri, BELRDF::RDF.type, BELRDF::BELV.Statement,     :graph_name => graph_name)
-      statements << ::RDF::Statement.new(uri, ::RDF::RDFS.label, to_s.force_encoding('UTF-8'),  :graph_name => graph_name)
+      statements << ::RDF::Statement.new(uri, BELRDF::RDFS.label, to_s.force_encoding('UTF-8'),  :graph_name => graph_name)
 
-      # evidence
-      evidence    = BELRDF::BELE[BELRDF.generate_uuid]
-      statements << ::RDF::Statement.new(evidence, BELRDF::RDF.type, BELRDF::BELV.Evidence, :graph_name => graph_name)
-      statements << ::RDF::Statement.new(uri, BELRDF::BELV.hasEvidence, evidence,             :graph_name => graph_name)
-      statements << ::RDF::Statement.new(evidence, BELRDF::BELV.hasStatement, uri,            :graph_name => graph_name)
+      # nanopub
+      nanopub    = BELRDF::BELE[BELRDF.generate_uuid]
+      statements << ::RDF::Statement.new(nanopub, BELRDF::RDF.type, BELRDF::BELV.Nanopub, :graph_name => graph_name)
+      statements << ::RDF::Statement.new(uri, BELRDF::BELV.hasNanopub, nanopub,             :graph_name => graph_name)
+      statements << ::RDF::Statement.new(nanopub, BELRDF::BELV.hasStatement, uri,            :graph_name => graph_name)
 
       # citation
       citation = @annotations.delete('Citation')
@@ -281,15 +282,15 @@ module BELRDF
         value = citation.value.map{|x| x.gsub('"', '')}
         if citation and value[0] == 'PubMed'
           pid = value[2]
-          statements << ::RDF::Statement.new(evidence, BELRDF::BELV.hasCitation, BELRDF::PUBMED[pid], :graph_name => graph_name)
+          statements << ::RDF::Statement.new(nanopub, BELRDF::BELV.hasCitation, BELRDF::PUBMED[pid], :graph_name => graph_name)
         end
       end
 
-      # evidence
-      evidence_text = @annotations.delete('Evidence')
-      if evidence_text
-        value = evidence_text.value.gsub('"', '').force_encoding('UTF-8')
-        statements << ::RDF::Statement.new(evidence, BELRDF::BELV.hasEvidenceText, value, :graph_name => graph_name)
+      # nanopub
+      support = @annotations.delete('Support')
+      if support
+        value = support.value.gsub('"', '').force_encoding('UTF-8')
+        statements << ::RDF::Statement.new(nanopub, BELRDF::BELV.hasSupport, value, :graph_name => graph_name)
       end
 
       # annotations
@@ -317,7 +318,7 @@ module BELRDF
           annotation_scheme = anno_rdf_uri ? anno_rdf_uri : BELRDF::const_get(name)
           [anno.value].flatten.map{|x| x.gsub('"', '')}.each do |val|
             value_uri = BELRDF::RDF::URI(URI.encode(annotation_scheme + val.to_s))
-            statements << ::RDF::Statement.new(evidence, BELRDF::BELV.hasAnnotation, value_uri, :graph_name => graph_name)
+            statements << ::RDF::Statement.new(nanopub, BELRDF::BELV.hasAnnotation, value_uri, :graph_name => graph_name)
           end
         end
       end
@@ -336,7 +337,7 @@ module BELRDF
     end
   end
 
-  class ::BEL::Model::Evidence
+  class ::BEL::Nanopub::Nanopub
 
     def to_uri
       BELRDF::BELE[BELRDF.generate_uuid]
@@ -346,15 +347,15 @@ module BELRDF
       uri                       = to_uri
 
       # parse BEL statement if necessary
-      unless self.bel_statement.is_a?(::BEL::Model::Statement)
+      unless self.bel_statement.is_a?(::BEL::Nanopub::Statement)
         self.bel_statement = self.class.parse_statement(self)
       end
 
       # convert BEL statement to RDF
       statement_uri, statements = bel_statement.to_rdf(uri, remap)
 
-      statements << ::RDF::Statement.new(uri,           BELRDF::RDF.type,          BELRDF::BELV.Evidence, :graph_name => uri)
-      statements << ::RDF::Statement.new(statement_uri, BELRDF::BELV.hasEvidence,  uri,                     :graph_name => uri)
+      statements << ::RDF::Statement.new(uri,           BELRDF::RDF.type,          BELRDF::BELV.Nanopub, :graph_name => uri)
+      statements << ::RDF::Statement.new(statement_uri, BELRDF::BELV.hasNanopub,  uri,                     :graph_name => uri)
       statements << ::RDF::Statement.new(uri,           BELRDF::BELV.hasStatement, statement_uri,           :graph_name => uri)
 
       annotations = bel_statement.annotations
@@ -369,11 +370,11 @@ module BELRDF
         end
       end
 
-      # evidence
-      evidence_text = annotations.delete('Evidence')
-      if evidence_text
-        value = evidence_text.value.gsub('"', '').force_encoding('UTF-8')
-        statements << ::RDF::Statement.new(uri, BELRDF::BELV.hasEvidenceText, value, :graph_name => uri)
+      # support
+      support = annotations.delete('Support')
+      if support
+        value = support.value.gsub('"', '').force_encoding('UTF-8')
+        statements << ::RDF::Statement.new(uri, BELRDF::BELV.hasSupport, value, :graph_name => uri)
       end
 
       # annotations
@@ -397,16 +398,16 @@ module BELRDF
       return nil if !document_header || !document_header.is_a?(Hash)
 
       triples = ::RDF::Repository.new
-      triples << ::RDF::Statement.new(void_dataset_uri, ::RDF.type, ::RDF::VOID.Dataset)
+      triples << ::RDF::Statement.new(void_dataset_uri, ::RDF.type, BELRDF::VOID.Dataset)
 
       name = version = nil
       document_header.each do |property, value|
         case property
           when /name/i
             name     = value.to_s
-            triples << ::RDF::Statement.new(void_dataset_uri, ::RDF::DC.title, name)
+            triples << ::RDF::Statement.new(void_dataset_uri, BELRDF::DC.title, name)
           when /description/i
-            triples << ::RDF::Statement.new(void_dataset_uri, ::RDF::DC.description, value.to_s)
+            triples << ::RDF::Statement.new(void_dataset_uri, BELRDF::DC.description, value.to_s)
           when /version/i
             version  = value.to_s
           when /copyright/i
@@ -423,10 +424,10 @@ module BELRDF
           when /authors/i
             if value.respond_to?(:each)
               value.each do |v|
-                triples << ::RDF::Statement.new(void_dataset_uri, ::RDF::DC.creator, v.to_s)
+                triples << ::RDF::Statement.new(void_dataset_uri, BELRDF::DC.creator, v.to_s)
               end
             else
-              triples << ::RDF::Statement.new(void_dataset_uri, ::RDF::DC.creator, value.to_s)
+              triples << ::RDF::Statement.new(void_dataset_uri, BELRDF::DC.creator, value.to_s)
             end
           when /licenses/i
             value = value.to_s
@@ -436,17 +437,17 @@ module BELRDF
                     else
                       value
                     end
-            triples << ::RDF::Statement.new(void_dataset_uri, ::RDF::DC.license, value)
+            triples << ::RDF::Statement.new(void_dataset_uri, BELRDF::DC.license, value)
           when /contactinfo/i
-            triples << ::RDF::Statement.new(void_dataset_uri, ::RDF::DC.publisher, :publisher)
-            triples << ::RDF::Statement.new(:publisher, ::RDF.type,          ::RDF::FOAF.Person)
-            triples << ::RDF::Statement.new(:publisher, ::RDF::FOAF.mbox,     value.to_s)
+            triples << ::RDF::Statement.new(void_dataset_uri, BELRDF::DC.publisher, :publisher)
+            triples << ::RDF::Statement.new(:publisher,       ::RDF.type,           BELRDF::FOAF.Person)
+            triples << ::RDF::Statement.new(:publisher,       BELRDF::FOAF.mbox,    value.to_s)
         end
       end
 
       if name && version
         identifier = "#{name}/#{version}"
-        triples << ::RDF::Statement.new(void_dataset_uri, ::RDF::DC.identifier, identifier)
+        triples << ::RDF::Statement.new(void_dataset_uri, BELRDF::DC.identifier, identifier)
       end
 
       triples

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

@@ -1,11 +1,11 @@
 module BELRDF
   module Reader
 
-    module EvidenceYielder
+    module NanopubYielder
 
       BELV = BELRDF::BELV
 
-      include ::BEL::Model
+      include ::BEL::Nanopub
       include ::BEL::Quoting
 
       # Find described resources by +type+ in +graph+.
@@ -36,44 +36,44 @@ module BELRDF
         }
       end
 
-      # Iterate the {BELV.Evidence} predicated statements, from the
-      # {::RDF::Graph graph}, and yield those correspdonding {Evidence}
+      # Iterate the {BELV.Nanopub} predicated statements, from the
+      # {::RDF::Graph graph}, and yield those correspdonding {Nanopub}
       # objects.
       #
       # @param  [::RDF::Graph]     graph the RDF graph to query
-      # @yield  [evidence_model] yields an {Evidence} object
-      def evidence_yielder(graph)
-        resources_of_type(BELV.Evidence, graph).each do |evidence|
+      # @yield  [::BEL::Nanopub::Nanopub] yields a nanopub object
+      def nanopub_yielder(graph)
+        resources_of_type(BELV.Nanopub, graph).each do |nanopub|
 
-          yield make_evidence(evidence, graph)
+          yield make_nanopub(nanopub, graph)
         end
       end
 
-      # Create an {Evidence} object from RDF statements found in
+      # Create an {Nanopub} object from RDF statements found in
       # the {::RDF::Graph graph}.
       #
-      # @param  [Hash]       evidence a hash of predicate to object
-      #         representing the described evidence
+      # @param  [Hash]       nanopub a hash of predicate to object
+      #         representing the described nanopub
       # @param  [::RDF::Graph] graph the RDF graph to query
-      # @return [Evidence]   the evidence model    
-      def make_evidence(evidence, graph)
-        statement     = describe(evidence[BELV.hasStatement], graph)
+      # @return [Nanopub]   the nanopub
+      def make_nanopub(nanopub_hash, graph)
+        statement     = describe(nanopub_hash[BELV.hasStatement], graph)
 
         # values
         bel_statement = statement[::RDF::RDFS.label].value
-        ev_text       = evidence[BELV.hasEvidenceText]
-        citation      = evidence[BELV.hasCitation]
+        support_text  = nanopub_hash[BELV.hasSupport]
+        citation      = nanopub_hash[BELV.hasCitation]
 
         # model
-        ev_model               = Evidence.new
-        ev_model.bel_statement = ::BEL::Script.parse(bel_statement)
+        nanopub               = Nanopub.new
+        nanopub.bel_statement = ::BEL::Script.parse(bel_statement)
                                    .find { |obj|
                                      obj.is_a? Statement
                                    }
-        ev_model.summary_text  = SummaryText.new(ev_text.value) if ev_text
+        nanopub.support       = Support.new(support_text.value) if support_text
 
         if citation.respond_to?(:value)
-          ev_model.citation =
+          nanopub.citation =
             case citation.value
             when /pubmed:(\d+)$/
               pubmed_id = $1.to_i
@@ -87,13 +87,13 @@ module BELRDF
             end
         end
 
-        ev_model
+        nanopub
       end
     end
 
-    class BufferedEvidenceYielder
+    class BufferedNanopubYielder
 
-      include EvidenceYielder
+      include NanopubYielder
 
       def initialize(data, format = :ntriples)
         @data   = data
@@ -108,8 +108,8 @@ module BELRDF
               graph << statement
             end
           end
-          evidence_yielder(graph) do |evidence_model|
-            yield evidence_model
+          nanopub_yielder(graph) do |nanopub|
+            yield nanopub
           end
         else
           to_enum(:each)
@@ -117,9 +117,9 @@ module BELRDF
       end
     end
 
-    class UnbufferedEvidenceYielder
+    class UnbufferedNanopubYielder
 
-      include EvidenceYielder
+      include NanopubYielder
 
       def initialize(data, format)
         @data   = data
@@ -128,27 +128,27 @@ module BELRDF
 
       def each
         if block_given?
-          graph             = RDF::Graph.new
-          evidence_resource = nil
+          graph   = RDF::Graph.new
+          nanopub = nil
           RDF::Reader.for(@format).new(@data) do |reader|
             reader.each_statement do |statement|
               case
-              when statement.object == BELV.Evidence &&
+              when statement.object == BELV.Nanopub &&
                    statement.predicate == RDF.type
-                evidence_resource = statement.subject
-              when evidence_resource &&
-                   statement.predicate != BELV.hasEvidence &&
-                   statement.subject != evidence_resource
-
-                # yield current graph as evidence model
-                yield make_evidence(
-                  describe(evidence_resource, graph),
+                nanopub = statement.subject
+              when nanopub &&
+                   statement.predicate != BELV.hasNanopub &&
+                   statement.subject != nanopub
+
+                # yield current graph as nanopub
+                yield make_nanopub(
+                  describe(nanopub, graph),
                   graph
                 )
 
                 # reset parse state
                 graph.clear
-                evidence_resource = nil
+                nanopub = nil
 
                 # insert this RDF statement
                 graph << statement
@@ -158,9 +158,9 @@ module BELRDF
             end
           end
 
-          # yield last graph as evidence model
-          yield make_evidence(
-            describe(evidence_resource, graph),
+          # yield last graph as nanopub
+          yield make_nanopub(
+            describe(nanopub, graph),
             graph
           )
         else