bel 0.7.0 → 1.0.0

data/lib/bel/translator/plugins/rdf2/converter.rb

@@ -0,0 +1,13 @@
+require 'rdf'
+
+module BEL
+  module BELRDF
+    module RDFConverter
+      # Convenience function to create an {RDF::Statement} given a triple
+      # of subject, predicate, and object.
+      def s(subject, predicate, object)
+        RDF::Statement.new(subject, predicate, object)
+      end
+    end
+  end
+end

data/lib/bel/translator/plugins/rdf2/namespace_converter.rb

@@ -0,0 +1,24 @@
+module BEL
+  module BELRDF
+    class NamespaceConverter
+
+      PREFIX_TERMINAL = '/'
+
+      # Convert a {BELParser::Expression::Model::Namespace} to {RDF::Graph} of
+      # RDF statements.
+      #
+      # @param  [BELParser::Expression::Model::Namespace] namespace
+      # @return [RDF::Graph] graph of RDF statements representing the namespace
+      def convert(namespace)
+        return nil if namespace.nil? || !namespace.uri?
+        NamespaceConverter.resolve_vocabulary(namespace.uri)
+      end
+
+      @namespace_vocabulary_hash = {}
+      def self.resolve_vocabulary(uri)
+        @namespace_vocabulary_hash[uri] ||=
+          RDF::Vocabulary.new("#{uri}#{PREFIX_TERMINAL}")
+      end
+    end
+  end
+end

data/lib/bel/translator/plugins/rdf2/nanopub_converter.rb

@@ -0,0 +1,82 @@
+require_relative 'uuid'
+require_relative 'rdf_converter'
+
+module BEL
+  module BELRDF
+    class NanopubConverter
+      include RDFConverter
+
+      def initialize(statement_converter)
+        @statement_converter = statement_converter
+      end
+
+      # Convert a {BEL::Nanopub::Nanopub} to {RDF::Graph} of RDF statements.
+      #
+      # @param  [BEL::Nanopub::Nanopub] nanopub
+      # @return [RDF::Graph] graph of RDF statements representing the nanopub
+      def convert(nanopub)
+        resource         = generate_nanopub_uri
+        graph            = RDF::Graph.new
+        graph           << s(resource, RDF.type, BELV2_0.Nanopub)
+
+        bel_statement(nanopub.bel_statement, resource, graph)
+        citation(nanopub.citation, resource, graph)
+        support(nanopub.support, resource, graph)
+        experiment_context(nanopub.experiment_context, resource, graph)
+        references(nanopub.references, resource, graph)
+        metadata(nanopub.metadata, resource, graph)
+
+        graph
+      end
+
+      protected
+
+      def bel_statement(statement, nr, ng)
+        path_part, stmt_uri, sg = @statement_converter.convert(statement)
+        ng << sg
+        ng << s(nr, BELV2_0.hasStatement, stmt_uri)
+      end
+
+      def citation(citation, nr, ng)
+        type = citation.type
+        if type && (type.to_s.downcase == 'pubmed')
+          ng << s(nr, BELV2_0.hasCitation, PUBMED[citation.id.to_s])
+        end
+      end
+
+      def support(support, nr, ng)
+        unless support.value.nil?
+          ng << s(nr, BELV2_0.hasSupport, support.to_s)
+        end
+      end
+
+      def experiment_context(experiment_context, nr, ng)
+      end
+
+      def references(references, nr, ng)
+      end
+
+      def metadata(metadata, nr, ng)
+        v = metadata.bel_version
+        bel_version(v, nr, ng) if v
+      end
+
+      def bel_version(bel_version, nr, ng)
+        spec = BELParser::Language.specification(bel_version) rescue nil
+        return unless spec
+
+        bel = RDF::URI(spec.uri)
+        ng << s(bel, RDF.type, BELV2_0.BiologicalExpressionLanguage)
+        ng << s(bel, BELV2_0.hasVersion, spec.version.to_s)
+        ng << s(nr, BELV2_0.hasBiologicalExpressionLanguage, bel)
+      end
+
+      private
+
+      # @api private
+      def generate_nanopub_uri
+        BELN[BELRDF.generate_uuid]
+      end
+    end
+  end
+end

data/lib/bel/translator/plugins/rdf2/parameter_converter.rb

@@ -0,0 +1,50 @@
+require          'rdf'
+require_relative 'rdf_converter'
+require_relative 'belv2_0'
+
+module BEL
+  module BELRDF
+    class ParameterConverter
+      include RDFConverter
+
+      def initialize(namespace_converter)
+        @namespace_converter = namespace_converter
+      end
+      # Convert a {BELParser::Expression::Model::Parameter} to {RDF::Graph} of
+      # RDF statements.
+      #
+      # @param  [BELParser::Expression::Model::Parameter] parameter
+      # @return [RDF::Graph] graph of RDF statements representing the parameter
+      def convert(parameter)
+        namespace_vocab = @namespace_converter.convert(parameter.namespace)
+        return nil unless namespace_vocab
+
+        value_s       = parameter.value.to_s
+        param_uri     = namespace_vocab[value_s]
+        pg            = RDF::Graph.new
+        if parameter.encoding
+          parameter.encoding.each do |enc|
+            concept_type = ENCODING_HASH[enc]
+            next unless concept_type
+            pg << s(param_uri, RDF.type, concept_type)
+          end
+        end
+        [param_uri, pg]
+      end
+
+      ENCODING_HASH = {
+        :A => BELV2_0.AbundanceConcept,
+        :B => BELV2_0.BiologicalProcessConcept,
+        :C => BELV2_0.ComplexConcept,
+        :E => BELV2_0.ProteinModificationConcept,
+        :G => BELV2_0.GeneConcept,
+        :L => BELV2_0.LocationConcept,
+        :M => BELV2_0.MicroRNAConcept,
+        :O => BELV2_0.PathologyConcept,
+        :P => BELV2_0.ProteinConcept,
+        :R => BELV2_0.RNAConcept,
+        :T => BELV2_0.MolecularActivityConcept
+      }.freeze
+    end
+  end
+end

data/lib/bel/translator/plugins/rdf2/rdf_converter.rb

@@ -0,0 +1,13 @@
+require 'rdf'
+
+module BEL
+  module BELRDF
+    module RDFConverter
+      # Convenience function to create an {RDF::Statement} given a triple
+      # of subject, predicate, and object.
+      def s(subject, predicate, object)
+        RDF::Statement.new(subject, predicate, object)
+      end
+    end
+  end
+end

data/lib/bel/translator/plugins/rdf2/rdf_writer.rb

@@ -0,0 +1,63 @@
+require_relative 'nanopub_converter'
+require_relative 'statement_converter'
+require_relative 'relationship_converter'
+require_relative 'term_converter'
+require_relative 'parameter_converter'
+require_relative 'namespace_converter'
+
+module BEL
+  module BELRDF
+    module Writer
+      class RDFWriter
+        attr_reader :writer
+
+        def initialize(io, format, options = {})
+          rdf_writer = RDF::Writer.for(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
+
+          @writer.write_prologue
+          @wrote_dataset = false
+          @nanopub_converter =
+            NanopubConverter.new(
+              StatementConverter.new(
+                TermConverter.new(
+                  ParameterConverter.new(
+                    NamespaceConverter.new)),
+                RelationshipConverter.new))
+        end
+
+        def <<(nanopub)
+          if !@wrote_dataset && @void_dataset_uri
+            # TODO Write VoID dataset for document.
+          end
+
+          @writer << @nanopub_converter.convert(nanopub)
+
+          # @nanopub_converter.nanopub(nanopub).each do |statement|
+          #   @writer.write_statement(statement)
+          # end
+
+          if @void_dataset_uri
+            # TODO Include this nanopub in the VoID dataset.
+            # @writer.write_statement(RDF::Statement.new(@void_dataset_uri, RDF::DC.hasPart, nanopub_uri))
+          end
+        end
+
+        def done
+          @writer.write_epilogue
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,172 @@
+require_relative 'belv2_0'
+
+module BEL
+  module BELRDF
+    module Reader
+      module NanopubYielder
+        include ::BEL::Nanopub
+        include ::BEL::Quoting
+
+        # Find described resources by +type+ in +graph+.
+        #
+        # @param  [::RDF::Resource] type the RDF type to find instances for
+        # @param  [::RDF::Graph]    graph the RDF graph to query
+        # @return [Enumerator]    an enumerator of described resource instances
+        def resources_of_type(type, graph)
+          graph.query([nil, ::RDF.type, type])
+            .lazy
+            .map { |rdf_statement|
+              describe(rdf_statement.subject, graph)
+            }
+        end
+
+        # Describes an RDF +resource+ contained within +graph+. Describing an RDF
+        # resource will retrieve the neighborhood of RDF statements with
+        # +resource+ in the subject position.
+        #
+        # @param  [::RDF::Resource] resource the RDF resource to describe
+        # @param  [::RDF::Graph]    graph the RDF graph to query
+        # @return [Hash]          a hash of predicate to object in the
+        #         neighborhood of +resource+
+        def describe(resource, graph)
+          graph.query([resource, nil, nil]).reduce({}) { |hash, statement|
+            hash[statement.predicate] = statement.object
+            hash
+          }
+        end
+
+        # 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  [::BEL::Nanopub::Nanopub] yields a nanopub object
+        def nanopub_yielder(graph)
+          resources_of_type(BELV.Nanopub, graph).each do |nanopub|
+
+            yield make_nanopub(nanopub, graph)
+          end
+        end
+
+        # Create an {Nanopub} object from RDF statements found in
+        # the {::RDF::Graph graph}.
+        #
+        # @param  [Hash]       nanopub a hash of predicate to object
+        #         representing the described nanopub
+        # @param  [::RDF::Graph] graph the RDF graph to query
+        # @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
+          support_text  = nanopub_hash[BELV.hasSupport]
+          citation      = nanopub_hash[BELV.hasCitation]
+
+          # model
+          nanopub               = Nanopub.new
+          nanopub.bel_statement = ::BEL::Script.parse(bel_statement)
+                                     .find { |obj|
+                                       obj.is_a? Statement
+                                     }
+          nanopub.support       = Support.new(support_text.value) if support_text
+
+          if citation.respond_to?(:value)
+            nanopub.citation =
+              case citation.value
+              when /pubmed:(\d+)$/
+                pubmed_id = $1.to_i
+                Citation.new({
+                  :type => 'PubMed',
+                  :id   => pubmed_id,
+                  :name => "PubMed Citation - #{pubmed_id}"
+                })
+              else
+                nil
+              end
+          end
+
+          nanopub
+        end
+      end
+
+      class BufferedNanopubYielder
+
+        include NanopubYielder
+
+        def initialize(data, format = :ntriples)
+          @data   = data
+          @format = format
+        end
+
+        def each
+          if block_given?
+            graph = RDF::Graph.new
+            RDF::Reader.for(@format).new(@data) do |reader|
+              reader.each_statement do |statement|
+                graph << statement
+              end
+            end
+            nanopub_yielder(graph) do |nanopub|
+              yield nanopub
+            end
+          else
+            to_enum(:each)
+          end
+        end
+      end
+
+      class UnbufferedNanopubYielder
+
+        include NanopubYielder
+
+        def initialize(data, format)
+          @data   = data
+          @format = format
+        end
+
+        def each
+          if block_given?
+            graph   = RDF::Graph.new
+            nanopub = nil
+            RDF::Reader.for(@format).new(@data) do |reader|
+              reader.each_statement do |statement|
+                case
+                when statement.object == BELV.Nanopub &&
+                     statement.predicate == RDF.type
+                  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
+                  nanopub = nil
+
+                  # insert this RDF statement
+                  graph << statement
+                else
+                  graph << statement
+                end
+              end
+            end
+
+            # yield last graph as nanopub
+            yield make_nanopub(
+              describe(nanopub, graph),
+              graph
+            )
+          else
+            to_enum(:each)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bel/translator/plugins/rdf2/relationship_converter.rb

@@ -0,0 +1,49 @@
+require          'rdf'
+require          'bel_parser/language/version2_0'
+require_relative 'rdf_converter'
+
+module BEL
+  module BELRDF
+    class RelationshipConverter
+      include BELParser::Language::Version2_0::Relationships
+      include RDFConverter
+
+      # Convert a version 2.0 {BELParser::Language::Relationship}
+      # to RDF statements.
+      #
+      # @param  [BELParser::Language::Relationship] relationship
+      # @return [RDF::Graph] graph of RDF statements representing the relationship
+      def convert(relationship)
+        return nil if relationship.nil?
+        [relationship.long.to_s, RELATIONSHIP_HASH[relationship]]
+      end
+
+      RELATIONSHIP_HASH = {
+        Analogous => BELV2_0.Analogous,
+        Association => BELV2_0.Association,
+        BiomarkerFor => BELV2_0.BiomarkerFor,
+        CausesNoChange => BELV2_0.CausesNoChange,
+        Decreases => BELV2_0.Decreases,
+        DirectlyDecreases => BELV2_0.DirectlyDecreases,
+        DirectlyIncreases => BELV2_0.DirectlyIncreases,
+        HasComponent => BELV2_0.HasComponent,
+        HasMember => BELV2_0.HasMember,
+        Increases => BELV2_0.Increases,
+        IsA => BELV2_0.IsA,
+        NegativeCorrelation => BELV2_0.NegativeCorrelation,
+        Orthologous => BELV2_0.Orthologous,
+        PositiveCorrelation => BELV2_0.PositiveCorrelation,
+        PrognosticBiomarkerFor => BELV2_0.PrognosticBiomarkerFor,
+        RateLimitingStepOf => BELV2_0.RateLimitingStepOf,
+        Regulates => BELV2_0.Regulates,
+        SubProcessOf => BELV2_0.SubProcessOf,
+        TranscribedTo => BELV2_0.TranscribedTo,
+        TranslatedTo => BELV2_0.TranslatedTo
+      }.freeze
+      # Special
+        # HasMembers
+        # HasComponents
+    end
+  end
+end
+