bel 0.7.0 → 1.0.0

data/lib/bel/{evidence_model → nanopub}/citation.rb

@@ -1,7 +1,7 @@
 module BEL
-  module Model
+  module Nanopub
 
-    # A Citation describes a cited reference which {Evidence} is derived from.
+    # A Citation describes a cited reference which {Nanopub} is derived from.
     #
     # @attr [String] type the type of resource the cited material appears in
     #       (e.g. PubMed, Journal, Book, Online Resource, etc...)

data/lib/bel/{evidence_model → nanopub}/experiment_context.rb

@@ -1,7 +1,7 @@
 require 'forwardable'
 
 module BEL
-  module Model
+  module Nanopub
     class ExperimentContext
 
       attr_reader :values
@@ -21,6 +21,12 @@ module BEL
         @values.sort_by! { |item| item[:name] }
       end
 
+      def ==(other)
+        return false if other.nil?
+        @values == other.values
+      end
+      alias eql? ==
+
       def_delegators :@values, :<<,    :[],    :"[]=",
                                :each,  :size,  :sort
     end

data/lib/bel/{evidence_model → nanopub}/hash_map_references.rb

@@ -1,7 +1,7 @@
 require_relative 'map_references'
 
 module BEL
-  module Model
+  module Nanopub
     class HashMapReferences
       include MapReferences
 

data/lib/bel/{evidence_model → nanopub}/map_references.rb

@@ -1,5 +1,5 @@
 module BEL
-  module Model
+  module Nanopub
     module MapReferences
 
       def annotation_references

data/lib/bel/nanopub/map_references_combiner.rb

@@ -0,0 +1,30 @@
+module BEL
+  module Nanopub
+
+    class MapReferencesCombiner < BufferingNanopubCombiner
+
+      def initialize(nanopub_collection, map_references)
+        @nanopub_collection = nanopub_collection
+        @map_references     = map_references
+      end
+
+      def annotation_references
+        @map_references.annotation_references
+      end
+
+      def namespace_references
+        @map_references.namespace_references
+      end
+
+      def each
+        if block_given?
+          @nanopub_collection.each do |nanopub|
+            yield rewrite_nanopub!(nanopub, @map_references)
+          end
+        else
+          to_enum(:each)
+        end
+      end
+    end
+  end
+end

data/lib/bel/nanopub/metadata.rb

@@ -0,0 +1,102 @@
+require 'forwardable'
+
+module BEL
+  module Nanopub
+    class Metadata
+
+      attr_reader :values
+
+      extend Forwardable
+      include Enumerable
+
+      BEL_VERSION     = :bel_version
+      DOCUMENT_HEADER = :document_header
+
+      def initialize(values = {})
+        if values.is_a? Array
+          @values = Hash[
+            values.map { |item|
+              name  = item[:name]  || item['name']
+              value = item[:value] || item['value']
+              [name.to_sym, value]
+            }
+          ]
+        else
+          @values = values
+        end
+
+        doc_hdr = @values[:document_header]
+        unless doc_hdr.nil?
+          @values[:document_header] = Hash[
+            doc_hdr.map { |item|
+              [item[0].to_sym, item[1]]
+            }
+          ]
+        end
+
+        unless @values.key?(:bel_version)
+          @values[:bel_version] = BELParser::Language.default_version
+        end
+
+        header = @values[:document_header]
+        unless header.nil?
+          authors = header[:Authors]
+          unless authors.is_a? Array
+            authors = [authors]
+            header[:Authors] = authors
+          end
+
+          licenses = header[:Licenses]
+          unless licenses.is_a? Array
+            licenses = [licenses]
+            header[:Licenses] = licenses
+          end
+        end
+      end
+
+      def bel_version
+        @values[BEL_VERSION]
+      end
+
+      def bel_version=(bel_version)
+        @values[BEL_VERSION] =
+          case bel_version
+          when BELParser::Language::Specification
+            bel_version.version.to_s
+          when String
+            bel_version
+          else
+            raise(
+              ArgumentError,
+              %(expected String, Specification; actual #{bel_version.class}))
+          end
+      end
+
+      def document_header
+        @values[DOCUMENT_HEADER] ||= {}
+      end
+
+      def document_header=(document_header)
+        @values[DOCUMENT_HEADER] = document_header
+      end
+
+      def ==(other)
+        return false if other.nil?
+        @values == other.values
+      end
+      alias eql? ==
+
+      def to_a
+        @values.each_pair.map { |key, value|
+          {
+            name:  key,
+            value: value
+          }
+        }
+      end
+
+      def_delegators :@values, :[],    :"[]=", :delete_if, :each, :each_pair,
+                               :fetch, :keys,  :size,      :sort, :store
+    end
+  end
+end

data/lib/bel/nanopub/nanopub.rb

@@ -0,0 +1,122 @@
+require 'bel'
+require 'bel_parser/expression'
+
+require_relative 'citation'
+require_relative 'support'
+require_relative 'experiment_context'
+require_relative 'references'
+require_relative 'metadata'
+
+module BEL
+  module Nanopub
+    # Nanopub represents an asserted biological interaction with associated
+    # constituents:
+    #
+    # - BEL Statement
+    # - Citation
+    # - Support
+    # - Experiment Context
+    # - References
+    # - Metadata
+    class Nanopub
+
+      def self.create(hash)
+        nanopub = Nanopub.new
+        # Order-dependent; metadata/references must be set first in order for
+        # _parse_statement to reference specification and namespaces.
+        nanopub.metadata           = Metadata.new(hash[:metadata] || {})
+        nanopub.references         = References.new(hash[:references] || {})
+        nanopub.bel_statement      = hash[:bel_statement] || nil
+        nanopub.citation           = Citation.new(hash[:citation] || {})
+        nanopub.support.value      = hash[:support] || nil
+        nanopub.experiment_context = ExperimentContext.new(hash[:experiment_context] || [])
+        nanopub
+      end
+
+      def bel_statement
+        @bel_statement
+      end
+
+      def bel_statement=(bel_statement)
+        @bel_statement =
+          case bel_statement
+          when String
+            _parse_statement(bel_statement)
+          when BELParser::Expression::Model::Statement
+            bel_statement
+          when nil
+            nil
+          else
+            raise ArgumentError, %(expected String, Statement, actual: #{bel_statement.class})
+          end
+      end
+
+      def citation
+        (@citation ||= Citation.new)
+      end
+
+      def citation=(citation)
+        @citation = citation
+      end
+
+      def support
+        (@support ||= Support.new)
+      end
+
+      def support=(support)
+        @support = support
+      end
+
+      def experiment_context
+        (@experiment_context ||= ExperimentContext.new)
+      end
+
+      def experiment_context=(experiment_context)
+        @experiment_context = experiment_context
+      end
+
+      def references
+        (@references ||= References.new)
+      end
+
+      def references=(references)
+        @references = references
+      end
+
+      def metadata
+        (@metadata ||= Metadata.new)
+      end
+
+      def metadata=(metadata)
+        @metadata = metadata
+      end
+
+      def to_h(hash = {})
+        hash.merge!(
+          {
+            :bel_statement      => bel_statement,
+            :citation           => citation.to_h,
+            :support            => support.value,
+            :experiment_context => experiment_context.values,
+            :references         => references.to_h,
+            :metadata           => metadata.to_a
+          }
+        )
+        hash
+      end
+
+      private
+
+      def _parse_statement(bel_statement)
+        bel_version =
+          metadata[:bel_version] || BELParser::Language.default_version
+        spec = BELParser::Language.specification(bel_version)
+        BELParser::Expression.parse_statements(
+          bel_statement,
+          spec,
+          references.namespaces_hash
+        )
+      end
+    end
+  end
+end

data/lib/bel/{evidence_model → nanopub}/references.rb

@@ -1,8 +1,9 @@
 require 'forwardable'
 require 'set'
+require 'bel_parser/expression/model/namespace'
 
 module BEL
-  module Model
+  module Nanopub
     class References
 
       attr_reader :values
@@ -17,7 +18,6 @@ module BEL
         @values = {}
 
         values.fetch(ANNOTATIONS, []).each do |annotation|
-
           add_annotation(
             annotation[:keyword],
             annotation[:type],
@@ -26,10 +26,10 @@ module BEL
         end
 
         values.fetch(NAMESPACES, []).each do |namespace|
-
           add_namespace(
             namespace[:keyword],
-            namespace[:uri]
+            namespace[:type],
+            namespace[:domain]
           )
         end
       end
@@ -38,6 +38,10 @@ module BEL
         @values[ANNOTATIONS] ||= []
       end
 
+      def annotations_hash
+        Hash[annotations.map { |ns| ns.values_at(:keyword, :domain) }]
+      end
+
       def annotations=(annotations)
         @values[ANNOTATIONS] = annotations
       end
@@ -46,56 +50,64 @@ module BEL
         @values[NAMESPACES] ||= []
       end
 
+      def namespaces_hash
+        Hash[ namespaces.map { |n| [n.keyword, n] } ]
+      end
+
       def namespaces=(namespaces)
         @values[NAMESPACES] = namespaces
       end
 
       def add_annotation(keyword, type, domain)
-        if type == :pattern
-          domain = case domain
-                   when Regexp
-                     domain
-                   else
-                     Regexp.new(domain.to_s)
-                   end
-        end
-
-        annotations << {
-          :keyword => keyword.to_sym,
-          :type    => type.to_sym,
-          :domain  => domain
-        }
-        annotations.sort_by! { |anno| anno[:keyword] }
+        annotation =
+          BELParser::Expression::Model::Annotation.new(
+            keyword,
+            type.to_sym,
+            domain)
+        annotations << annotation
+        annotations.sort_by! { |a| a.keyword }
       end
 
-      def add_namespace(keyword, uri)
-        namespaces << {
-          :keyword => keyword.to_sym,
-          :uri => uri
-        }
-        namespaces.sort_by! { |ns| ns[:keyword] }
+      def add_namespace(keyword, type, domain)
+        case type
+        when :uri
+          uri = domain
+          url = nil
+        when :url
+          url = domain
+          uri = nil
+        end
+
+        namespace =
+          BELParser::Expression::Model::Namespace.new(
+            keyword.to_s,
+            uri,
+            url)
+        namespaces << namespace
+        namespaces.sort_by! { |n| n.keyword }
       end
 
       def to_h(hash = {})
         hash[ANNOTATIONS] = annotations.map { |anno|
-          keyword, type, domain = anno.values_at(:keyword, :type, :domain)
-
-          domain = case domain
-                   when Regexp
-                     domain.source
-                   else
-                     domain
-                   end
-
           {
-            :keyword => keyword,
-            :type    => type,
-            :domain  => domain
+            :keyword => anno.keyword,
+            :type    => anno.type,
+            :domain  =>
+              case anno.domain
+              when Regexp
+                anno.domain.source
+              else
+                anno.domain
+              end
           }
         }
 
         hash[NAMESPACES] = namespaces.map { |ns|
-          ns.dup
+          {
+            :keyword => ns.keyword,
+            :type    => ns.type,
+            :domain  => ns.domain
+          }
         }
 
         hash

data/lib/bel/{evidence_model/streaming_evidence_combiner.rb → nanopub/streaming_nanopub_combiner.rb}

@@ -1,23 +1,23 @@
 module BEL
-  module Model
+  module Nanopub
 
-    class StreamingEvidenceCombiner
+    class StreamingNanopubCombiner
 
       attr_reader :annotation_references, :namespace_references
 
-      def initialize(evidence_collection)
-        @evidence_collection   = evidence_collection
+      def initialize(nanopub_collection)
+        @nanopub_collection = nanopub_collection
       end
 
       def each
         if block_given?
-          @evidence_collection.each do |evidence|
+          @nanopub_collection.each do |nanopub|
             once {
-              @annotation_references = evidence.references.annotations
-              @namespace_references  = evidence.references.namespaces
+              @annotation_references = nanopub.references.annotations
+              @namespace_references  = nanopub.references.namespaces
             }
 
-            yield evidence
+            yield nanopub
           end
         else
           to_enum(:each)