bel 0.4.0.beta.8 → 0.4.0.beta.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e22bc8ddb611afaba61076e5e2ac66dc89ff9a59
-  data.tar.gz: 54c075abe536cd62000858f19e88cdaad4b1ab79
+  metadata.gz: c2439b3403f830ef0c8117b3bd1ed9ef6cd589c4
+  data.tar.gz: 9a5279406ef99030abb59b2b4f19960d03b43b18
 SHA512:
-  metadata.gz: e994fee183fbcedbcec2b6728a9095299eb506e3ec0d8e9a2935b589eaff302498c3318fe5ffd25919490b80803db1d5cf4b9ede339099cb6630efc96d2e27ab
-  data.tar.gz: d6573b1c9965ee341f154a03f11c1a50f9392db3d5264c984d6e976435090e6c4f70c8e186e85e46228676791fe46514e6c5610a2e45c22df1b42739f33e02c9
+  metadata.gz: 8acf51e5234ecdb58206b761451dda5437097eec73c0200ae165985cffbc5bdf27bf3eef7931dad3bfbb48affdacf75a72fbb4e4e1d24d45ce9a39ee99ea4592
+  data.tar.gz: f003e2105ad90a3eae32872b6c58b97a310ea3ec035cd3a82f1af1f2af56c4930c5a0117a1df6d12b0321116222b06c8ceb8572e17c42fb0f48da39aac892d2b

data/lib/bel/translate.rb

@@ -50,7 +50,7 @@ module BEL
           raise TranslateError.new(output_format)
 
         evidence = in_translator.read(prepared_input)
-        output   = out_translator.write(evidence, writer)
+        out_translator.write(evidence, writer, options)
         writer
       end
 

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

@@ -1,3 +1,4 @@
+require          'bel/evidence_model'
 require_relative 'uuid'
 
 module BEL::Translator::Plugins
@@ -5,6 +6,7 @@ module BEL::Translator::Plugins
   module Rdf
 
     # OpenClass to contribute RDF functionality to BEL Model.
+
     class ::BEL::Namespace::NamespaceDefinition
 
       def to_uri
@@ -18,43 +20,38 @@ module BEL::Translator::Plugins
 
     class ::BEL::Model::Parameter
 
+      CONCEPT_ENCODING = {
+        :G => BEL::RDF::BELV.GeneConcept,
+        :R => BEL::RDF::BELV.RNAConcept,
+        :P => BEL::RDF::BELV.ProteinConcept,
+        :M => BEL::RDF::BELV.MicroRNAConcept,
+        :C => BEL::RDF::BELV.ComplexConcept,
+        :B => BEL::RDF::BELV.BiologicalProcessConcept,
+        :A => BEL::RDF::BELV.AbundanceConcept,
+        :O => BEL::RDF::BELV.PathologyConcept,
+      }
+
       def to_uri
         @ns.to_rdf_vocabulary[URI::encode(@value)]
       end
 
-      def to_rdf
+      def to_rdf(graph_name = nil)
         uri = to_uri
         encodings = ['A'].concat(@enc.to_s.each_char.to_a).uniq
         if block_given?
-          encodings.map { |enc| concept_statement(enc, uri) }.each do |stmt|
+          encodings.map { |enc| concept_statement(enc, uri, graph_name) }.each do |stmt|
             yield stmt
           end
         else
-          encodings.map { |enc| concept_statement(enc, uri)}
+          encodings.map { |enc| concept_statement(enc, uri, graph_name)}
         end
       end
 
       private
 
-      def concept_statement(encoding_character, uri)
-          case encoding_character
-          when 'G'
-            ::RDF::Statement(uri, ::RDF.type, BEL::RDF::BELV.GeneConcept)
-          when 'R'
-            ::RDF::Statement(uri, ::RDF.type, BEL::RDF::BELV.RNAConcept)
-          when 'P'
-            ::RDF::Statement(uri, ::RDF.type, BEL::RDF::BELV.ProteinConcept)
-          when 'M'
-            ::RDF::Statement(uri, ::RDF.type, BEL::RDF::BELV.MicroRNAConcept)
-          when 'C'
-            ::RDF::Statement(uri, ::RDF.type, BEL::RDF::BELV.ComplexConcept)
-          when 'B'
-            ::RDF::Statement(uri, ::RDF.type, BEL::RDF::BELV.BiologicalProcessConcept)
-          when 'A'
-            ::RDF::Statement(uri, ::RDF.type, BEL::RDF::BELV.AbundanceConcept)
-          when 'O'
-            ::RDF::Statement(uri, ::RDF.type, BEL::RDF::BELV.PathologyConcept)
-          end
+      def concept_statement(encoding_character, uri, graph_name = nil)
+        encoding = CONCEPT_ENCODING.fetch(encoding_character.to_sym, BEL::RDF::BELV.AbundanceConcept)
+        ::RDF::Statement(uri, ::RDF.type, encoding, :graph_name => graph_name)
       end
     end
 
@@ -100,21 +97,21 @@ module BEL::Translator::Plugins
         end
       end
 
-      def to_rdf
+      def to_rdf(graph_name = nil)
         uri = to_uri
         statements = []
 
         # rdf:type
         type = rdf_type
-        statements << [uri, BEL::RDF::RDF.type, BEL::RDF::BELV.Term]
-        statements << [uri, BEL::RDF::RDF.type, type]
+        statements << ::RDF::Statement.new(uri, BEL::RDF::RDF.type, BEL::RDF::BELV.Term, :graph_name => graph_name)
+        statements << ::RDF::Statement.new(uri, BEL::RDF::RDF.type, type, :graph_name => graph_name)
         fx = @fx.respond_to?(:short_form) ? @fx.short_form : @fx.to_s.to_sym
         if BEL::RDF::ACTIVITY_TYPE.include? fx
-          statements << [uri, BEL::RDF::BELV.hasActivityType, BEL::RDF::ACTIVITY_TYPE[fx]]
+          statements << ::RDF::Statement.new(uri, BEL::RDF::BELV.hasActivityType, BEL::RDF::ACTIVITY_TYPE[fx], :graph_name => graph_name)
         end
 
         # rdfs:label
-        statements << [uri, BEL::RDF::RDFS.label, to_s.force_encoding('UTF-8')]
+        statements << ::RDF::Statement.new(uri, BEL::RDF::RDFS.label, to_s.force_encoding('UTF-8'), :graph_name => graph_name)
 
         # special proteins (does not recurse into pmod)
         if [:p, :proteinAbundance].include?(fx)
@@ -132,22 +129,22 @@ module BEL::Translator::Plugins
             mod_string = pmod.arguments.map(&:to_s).join(',')
             mod_type = BEL::RDF::MODIFICATION_TYPE.find {|k,v| mod_string.start_with? k}
             mod_type = (mod_type ? mod_type[1] : BEL::RDF::BELV.Modification)
-            statements << [uri, BEL::RDF::BELV.hasModificationType, mod_type]
+            statements << ::RDF::Statement.new(uri, BEL::RDF::BELV.hasModificationType, mod_type, :graph_name => graph_name)
             last = pmod.arguments.last.to_s
             if last.match(/^\d+$/)
-              statements << [uri, BEL::RDF::BELV.hasModificationPosition, last.to_i]
+              statements << ::RDF::Statement.new(uri, BEL::RDF::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
-            statements << [uri, BEL::RDF::BELV.hasChild, root_id]
+            statements << ::RDF::Statement.new(uri, BEL::RDF::BELV.hasChild, root_id, :graph_name => graph_name)
             statements += root_statements
             return [uri, statements]
           elsif @arguments.find{|x| x.is_a? ::BEL::Model::Term and BEL::RDF::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
-            statements << [uri, BEL::RDF::BELV.hasChild, root_id]
+            statements << ::RDF::Statement.new(uri, BEL::RDF::BELV.hasChild, root_id, :graph_name => graph_name)
             statements += root_statements
             return [uri, statements]
           end
@@ -158,17 +155,17 @@ module BEL::Translator::Plugins
           x.is_a? ::BEL::Model::Parameter and x.ns != nil
         }.each do |param|
           concept_uri = param.ns.to_uri + param.value.to_s
-          statements << [uri, BEL::RDF::BELV.hasConcept, BEL::RDF::RDF::URI(URI.encode(concept_uri))]
+          statements << ::RDF::Statement.new(uri, BEL::RDF::BELV.hasConcept, BEL::RDF::RDF::URI(URI.encode(concept_uri)), :graph_name => graph_name)
         end
 
         # BEL::RDF::BELV.hasChild]
         @arguments.find_all{|x| x.is_a? ::BEL::Model::Term}.each do |child|
           (child_id, child_statements) = child.to_rdf
-          statements << [uri, BEL::RDF::BELV.hasChild, child_id]
+          statements << ::RDF::Statement.new(uri, BEL::RDF::BELV.hasChild, child_id, :graph_name => graph_name)
           statements += child_statements
         end
 
-        return [uri, statements]
+        [uri, statements]
       end
     end
 
@@ -176,9 +173,6 @@ module BEL::Translator::Plugins
 
       def to_uri
         case
-        when subject_only?
-          tid = @subject.to_s.squeeze(')').gsub(/[")\[\]]/, '').gsub(/[(:, ]/, '_')
-          BEL::RDF::BELR[URI::encode(tid)]
         when simple?
           sub_id = @subject.to_s.squeeze(')').gsub(/[")\[\]]/, '').gsub(/[(:, ]/, '_')
           obj_id = @object.to_s.squeeze(')').gsub(/[")\[\]]/, '').gsub(/[(:, ]/, '_')
@@ -206,17 +200,21 @@ module BEL::Translator::Plugins
             nrel = @object.relationship.to_s
           end
           BEL::RDF::BELR[URI::encode("#{sub_id}_#{rel}_#{nsub_id}_#{nrel}_#{nobj_id}")]
+        else
+          # Interpret as subject only BEL statement.
+          tid = @subject.to_s.squeeze(')').gsub(/[")\[\]]/, '').gsub(/[(:, ]/, '_')
+          BEL::RDF::BELR[URI::encode(tid)]
         end
       end
 
-      def to_rdf
-        uri = to_uri
+      def to_rdf(graph_name = nil)
+        uri        = to_uri
         statements = []
 
         case
         when subject_only?
           (sub_uri, sub_statements) = @subject.to_rdf
-          statements << [uri, BEL::RDF::BELV.hasSubject, sub_uri]
+          statements << ::RDF::Statement(uri, BEL::RDF::BELV.hasSubject, sub_uri, :graph_name => graph_name)
           statements += sub_statements
         when simple?
           (sub_uri, sub_statements) = @subject.to_rdf
@@ -226,9 +224,9 @@ module BEL::Translator::Plugins
           statements += obj_statements
 
           rel = BEL::RDF::RELATIONSHIP_TYPE[@relationship.to_s]
-          statements << [uri, BEL::RDF::BELV.hasSubject, sub_uri]
-          statements << [uri, BEL::RDF::BELV.hasObject, obj_uri]
-          statements << [uri, BEL::RDF::BELV.hasRelationship, rel]
+          statements << ::RDF::Statement(uri, BEL::RDF::BELV.hasSubject, sub_uri,  :graph_name => graph_name)
+          statements << ::RDF::Statement(uri, BEL::RDF::BELV.hasObject, obj_uri,   :graph_name => graph_name)
+          statements << ::RDF::Statement(uri, BEL::RDF::BELV.hasRelationship, rel, :graph_name => graph_name)
         when nested?
           (sub_uri, sub_statements) = @subject.to_rdf
           (nsub_uri, nsub_statements) = @object.subject.to_rdf
@@ -241,25 +239,25 @@ module BEL::Translator::Plugins
           nuri = BEL::RDF::BELR["#{strip_prefix(nsub_uri)}_#{nrel}_#{strip_prefix(nobj_uri)}"]
 
           # inner
-          statements << [nuri, BEL::RDF::BELV.hasSubject, nsub_uri]
-          statements << [nuri, BEL::RDF::BELV.hasObject, nobj_uri]
-          statements << [nuri, BEL::RDF::BELV.hasRelationship, nrel]
+          statements << ::RDF::Statement.new(nuri, BEL::RDF::BELV.hasSubject, nsub_uri,  :graph_name => graph_name)
+          statements << ::RDF::Statement.new(nuri, BEL::RDF::BELV.hasObject, nobj_uri,   :graph_name => graph_name)
+          statements << ::RDF::Statement.new(nuri, BEL::RDF::BELV.hasRelationship, nrel, :graph_name => graph_name)
 
           # outer
-          statements << [uri, BEL::RDF::BELV.hasSubject, sub_uri]
-          statements << [uri, BEL::RDF::BELV.hasObject, nuri]
-          statements << [uri, BEL::RDF::BELV.hasRelationship, rel]
+          statements << ::RDF::Statement.new(uri, BEL::RDF::BELV.hasSubject, sub_uri,  :graph_name => graph_name)
+          statements << ::RDF::Statement.new(uri, BEL::RDF::BELV.hasObject, nuri,      :graph_name => graph_name)
+          statements << ::RDF::Statement.new(uri, BEL::RDF::BELV.hasRelationship, rel, :graph_name => graph_name)
         end
 
         # common statement triples
-        statements << [uri, BEL::RDF::RDF.type, BEL::RDF::BELV.Statement]
-        statements << [uri, ::RDF::RDFS.label, to_s.force_encoding('UTF-8')]
+        statements << ::RDF::Statement.new(uri, BEL::RDF::RDF.type, BEL::RDF::BELV.Statement,     :graph_name => graph_name)
+        statements << ::RDF::Statement.new(uri, ::RDF::RDFS.label, to_s.force_encoding('UTF-8'),  :graph_name => graph_name)
 
         # evidence
         evidence    = BEL::RDF::BELE[Rdf.generate_uuid]
-        statements << [evidence, BEL::RDF::RDF.type, BEL::RDF::BELV.Evidence]
-        statements << [uri, BEL::RDF::BELV.hasEvidence, evidence]
-        statements << [evidence, BEL::RDF::BELV.hasStatement, uri]
+        statements << ::RDF::Statement.new(evidence, BEL::RDF::RDF.type, BEL::RDF::BELV.Evidence, :graph_name => graph_name)
+        statements << ::RDF::Statement.new(uri, BEL::RDF::BELV.hasEvidence, evidence,             :graph_name => graph_name)
+        statements << ::RDF::Statement.new(evidence, BEL::RDF::BELV.hasStatement, uri,            :graph_name => graph_name)
 
         # citation
         citation = @annotations.delete('Citation')
@@ -267,11 +265,7 @@ module BEL::Translator::Plugins
           value = citation.value.map{|x| x.gsub('"', '')}
           if citation and value[0] == 'PubMed'
             pid = value[2]
-            statements << [
-              evidence,
-              BEL::RDF::BELV.hasCitation,
-              BEL::RDF::PUBMED[pid]
-            ]
+            statements << ::RDF::Statement.new(evidence, BEL::RDF::BELV.hasCitation, BEL::RDF::PUBMED[pid], :graph_name => graph_name)
           end
         end
 
@@ -279,23 +273,23 @@ module BEL::Translator::Plugins
         evidence_text = @annotations.delete('Evidence')
         if evidence_text
           value = evidence_text.value.gsub('"', '').force_encoding('UTF-8')
-          statements << [evidence, BEL::RDF::BELV.hasEvidenceText, value]
+          statements << ::RDF::Statement.new(evidence, BEL::RDF::BELV.hasEvidenceText, value, :graph_name => graph_name)
         end
 
         # annotations
-        @annotations.each do |name, anno|
+        @annotations.each do |_, anno|
           name = anno.name.gsub('"', '')
 
           if BEL::RDF::const_defined? name
             annotation_scheme = BEL::RDF::const_get name
             [anno.value].flatten.map{|x| x.gsub('"', '')}.each do |val|
               value_uri = BEL::RDF::RDF::URI(URI.encode(annotation_scheme + val.to_s))
-              statements << [evidence, BEL::RDF::BELV.hasAnnotation, value_uri]
+              statements << ::RDF::Statement.new(evidence, BEL::RDF::BELV.hasAnnotation, value_uri, :graph_name => graph_name)
             end
           end
         end
 
-        return [uri, statements]
+        [uri, statements]
       end
 
       private
@@ -308,5 +302,115 @@ module BEL::Translator::Plugins
         end
       end
     end
+
+    class ::BEL::Model::Evidence
+
+      def to_uri
+        BEL::RDF::BELE[Rdf.generate_uuid]
+      end
+
+      def to_rdf
+        uri                       = to_uri
+        statement_uri, statements = bel_statement.to_rdf(uri)
+
+        statements << ::RDF::Statement.new(uri,           BEL::RDF::RDF.type,          BEL::RDF::BELV.Evidence, :graph_name => uri)
+        statements << ::RDF::Statement.new(statement_uri, BEL::RDF::BELV.hasEvidence,  uri,                     :graph_name => uri)
+        statements << ::RDF::Statement.new(uri,           BEL::RDF::BELV.hasStatement, statement_uri,           :graph_name => uri)
+
+        annotations = bel_statement.annotations
+
+        # citation
+        citation = annotations.delete('Citation')
+        if citation
+          value = citation.value.map{|x| x.gsub('"', '')}
+          if citation and value[0] == 'PubMed'
+            pid = value[2]
+            statements << ::RDF::Statement.new(uri, BEL::RDF::BELV.hasCitation, BEL::RDF::PUBMED[pid], :graph_name => uri)
+          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, BEL::RDF::BELV.hasEvidenceText, value, :graph_name => uri)
+        end
+
+        # annotations
+        annotations.each do |_, anno|
+          name = anno.name.gsub('"', '')
+
+          if BEL::RDF::const_defined? name
+            annotation_scheme = BEL::RDF::const_get name
+            [anno.value].flatten.map{|x| x.gsub('"', '')}.each do |val|
+              value_uri = BEL::RDF::RDF::URI(URI.encode(annotation_scheme + val.to_s))
+              statements << ::RDF::Statement.new(uri, BEL::RDF::BELV.hasAnnotation, value_uri, :graph_name => uri)
+            end
+          end
+        end
+
+        [uri, statements]
+      end
+
+      def to_void_dataset(void_dataset_uri)
+        document_header = self.metadata[:document_header]
+        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)
+
+        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)
+            when /description/i
+              triples << ::RDF::Statement.new(void_dataset_uri, ::RDF::DC.description, value.to_s)
+            when /version/i
+              version  = value.to_s
+            when /copyright/i
+              waiver = RDF::Vocabulary.new('http://vocab.org/waiver/terms/').waiver
+
+              value = value.to_s
+              uri   = RDF::URI(value)
+              value = if uri.valid?
+                        uri
+                      else
+                        value
+                      end
+              triples << ::RDF::Statement.new(void_dataset_uri, waiver, value)
+            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)
+                end
+              else
+                triples << ::RDF::Statement.new(void_dataset_uri, ::RDF::DC.creator, value.to_s)
+              end
+            when /licenses/i
+              value = value.to_s
+              uri   = RDF::URI(value)
+              value = if uri.valid?
+                        uri
+                      else
+                        value
+                      end
+              triples << ::RDF::Statement.new(void_dataset_uri, ::RDF::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)
+          end
+        end
+
+        if name && version
+          identifier = "#{name}/#{version}"
+          triples << ::RDF::Statement.new(void_dataset_uri, ::RDF::DC.identifier, identifier)
+        end
+
+        triples
+      end
+    end
   end
 end

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

@@ -20,7 +20,7 @@ module BEL::Translator::Plugins
 
       def write(objects, writer = StringIO.new, options = {})
         # format = options[:format] || :ntriples
-        rdf_writer = Writer::RDFYielder.new(writer, :nquads)
+        rdf_writer = Writer::RDFYielder.new(writer, :nquads, options)
 
         objects.each do |evidence|
           rdf_writer << evidence

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

@@ -9,17 +9,37 @@ module BEL::Translator::Plugins
 
       Rdf = ::BEL::Translator::Plugins::Rdf
 
-      def initialize(io, format)
-        rdf_writer = find_writer(format)
-        @writer = rdf_writer.new(io, { :stream => true })
+      def initialize(io, format, options = {})
+        rdf_writer       = find_writer(format)
+        @writer          = rdf_writer.new(io, { :stream => true })
+
+        if options[:void_dataset_uri]
+          void_dataset_uri = options.delete(:void_dataset_uri)
+          void_dataset_uri = RDF::URI(void_dataset_uri)
+          unless void_dataset_uri.valid?
+            raise ArgumentError.new 'void_dataset_uri is not a valid URI'
+          end
+          @void_dataset_uri = void_dataset_uri
+        else
+          @void_dataset_uri = nil
+        end
+        @wrote_dataset    = false
       end
 
       def <<(evidence)
-        graph = RDF::URI("http://www.openbel.org/evidence-graphs/#{Rdf.generate_uuid}")
-        triples = evidence.bel_statement.to_rdf[1]
-        triples.each do |triple|
-          @writer.write_statement(::RDF::Statement(*triple, :graph_name => graph))
+        if !@wrote_dataset && @void_dataset_uri
+          void_dataset_triples = evidence.to_void_dataset(@void_dataset_uri)
+          if void_dataset_triples && void_dataset_triples.respond_to?(:each)
+            void_dataset_triples.each do |void_triple|
+              @writer.write_statement(void_triple)
+            end
+          end
+        end
+        evidence_uri, statements = evidence.to_rdf
+        statements.each do |statement|
+          @writer.write_statement(statement)
         end
+        @writer.write_statement(RDF::Statement.new(@void_dataset_uri, RDF::DC.hasPart, evidence_uri))
       end
 
       def done

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

@@ -9,7 +9,7 @@ module BEL::Translator::Plugins
 
       include ::BEL::Translator
 
-      def read(data)
+      def read(data, options = {})
         EvidenceYielder.new(data)
       end
 

data/lib/bel/version.rb

@@ -1,3 +1,3 @@
 module BEL
-  VERSION = '0.4.0.beta.8'
+  VERSION = '0.4.0.beta.9'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bel
 version: !ruby/object:Gem::Version
-  version: 0.4.0.beta.8
+  version: 0.4.0.beta.9
 platform: ruby
 authors:
 - Anthony Bargnesi
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-12-09 00:00:00.000000000 Z
+date: 2015-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -207,4 +207,3 @@ signing_key:
 specification_version: 4
 summary: Process BEL with ruby.
 test_files: []
-has_rdoc: