bel 0.5.0 → 0.6.0

data/lib/bel/evidence_model/hash_map_references.rb

@@ -0,0 +1,33 @@
+require_relative 'map_references'
+
+module BEL
+  module Model
+    class HashMapReferences
+      include MapReferences
+
+      def initialize(annotation_reference_map, namespace_reference_map)
+        @annotation_reference_map = annotation_reference_map
+        @namespace_reference_map  = namespace_reference_map
+
+        @annotation_references = annotation_reference_map.values.uniq
+        @namespace_references  = namespace_reference_map.values.uniq
+      end
+
+      def annotation_references
+        @annotation_references
+      end
+
+      def namespace_references
+        @namespace_references
+      end
+
+      def map_annotation_reference(reference)
+        @annotation_reference_map[reference]
+      end
+
+      def map_namespace_reference(reference)
+        @namespace_reference_map[reference]
+      end
+    end
+  end
+end

data/lib/bel/evidence_model/map_references.rb

@@ -0,0 +1,30 @@
+module BEL
+  module Model
+    module MapReferences
+
+      def annotation_references
+        raise NotImplementedError.new(
+          "#{__method__} is not implemented for class #{self.class}"
+        )
+      end
+
+      def namespace_references
+        raise NotImplementedError.new(
+          "#{__method__} is not implemented for class #{self.class}"
+        )
+      end
+
+      def map_annotation_reference(reference)
+        raise NotImplementedError.new(
+          "#{__method__} is not implemented for class #{self.class}"
+        )
+      end
+
+      def map_namespace_reference(reference)
+        raise NotImplementedError.new(
+          "#{__method__} is not implemented for class #{self.class}"
+        )
+      end
+    end
+  end
+end

data/lib/bel/evidence_model/map_references_combiner.rb

@@ -0,0 +1,30 @@
+module BEL
+  module Model
+
+    class MapReferencesCombiner < BufferingEvidenceCombiner
+
+      def initialize(evidence_collection, map_references)
+        @evidence_collection   = evidence_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?
+          @evidence_collection.each do |evidence|
+            yield rewrite_evidence!(evidence, @map_references)
+          end
+        else
+          to_enum(:each)
+        end
+      end
+    end
+  end
+end

data/lib/bel/evidence_model/streaming_evidence_combiner.rb

@@ -0,0 +1,37 @@
+module BEL
+  module Model
+
+    class StreamingEvidenceCombiner
+
+      attr_reader :annotation_references, :namespace_references
+
+      def initialize(evidence_collection)
+        @evidence_collection   = evidence_collection
+      end
+
+      def each
+        if block_given?
+          @evidence_collection.each do |evidence|
+            once {
+              @annotation_references = evidence.references.annotations
+              @namespace_references  = evidence.references.namespaces
+            }
+
+            yield evidence
+          end
+        else
+          to_enum(:each)
+        end
+      end
+
+      private
+
+      def once(*block_args, &block)
+        unless @_once_switch
+          block.call(*block_args)
+          @_once_switch = 1
+        end
+      end
+    end
+  end
+end

data/lib/bel/evidence_model/util.rb

@@ -0,0 +1,84 @@
+module BEL
+  module Model
+
+    def self.union_namespace_references(destination, source, suffix = 'incr')
+      BEL::Model.union_by_keyword(
+        destination,
+        source,
+        suffix
+      )
+    end
+
+    def self.union_annotation_references(destination, source, suffix = 'incr')
+      BEL::Model.union_by_keyword(
+        destination,
+        source,
+        suffix
+      )
+    end
+
+    # Combines annotation/namespace references together by disambiguating
+    # the keywords. The references in @source@ are combined into
+    # @destination@.
+    #
+    # @param  [Array<Hash>] destination existing references to merge with; may
+    #         be an empty @[]@ array
+    # @param  [Array<Hash>] source references to union with @destination@
+    # @param  [String]      suffix the suffix to apply to reference keywords
+    #         in @source@ for disambiguation
+    # @return [Array<Array<Hash>,Hash>] array where the first item is and
+    #         Array of combined references and the second item is a Hash that
+    #         remaps references from source
+    def self.union_by_keyword(destination, source, suffix = 'incr')
+      # find new
+      new            = source - destination
+      suffix_pattern = /#{Regexp.escape(suffix)}([0-9]+)$/
+      remap_result   = {}
+
+      combined = destination + new.map { |new_obj|
+        new_key = new_obj[:keyword].to_s
+
+        # find a match where the keyword differs
+        new_value      = new_obj.reject { |key, value| key == :keyword }
+        match_by_value = destination.find { |dest|
+          new_value == dest.reject { |key, value| key == :keyword }
+        }
+
+        rewrite_key =
+          if match_by_value
+            match_by_value[:keyword]
+          else
+            # find max suffix match
+            max_suffix = destination.map { |dest|
+              key, suffix_number = dest[:keyword].to_s.split(suffix_pattern)
+              if new_key == key
+                suffix_number
+              else
+                nil
+              end
+            }.compact.max { |suffix_number|
+              suffix_number.to_i
+            }
+
+            if max_suffix
+              new_key + suffix + max_suffix.next
+            else
+              if destination.any? { |dest| dest[:keyword] == new_key }
+                "#{new_key}#{suffix}1"
+              else
+                new_key
+              end
+            end
+          end
+
+        rewrite_obj           = new_obj.merge({:keyword => rewrite_key})
+        remap_result[new_obj] = rewrite_obj
+        rewrite_obj
+      }
+      combined.uniq!
+
+      [combined, remap_result]
+    end
+
+  end
+end

data/lib/bel/gen.rb

@@ -38,11 +38,15 @@ module BEL
 end
 
 # Load generators after {BEL::Gen#soft_require} is available.
-require_relative 'gen/evidence'
+require_relative 'gen/document_header'
 require_relative 'gen/annotation'
 require_relative 'gen/citation'
-require_relative 'gen/bel_expression'
-require_relative 'gen/document_header'
+require_relative 'gen/namespace'
+require_relative 'gen/parameter'
+require_relative 'gen/term'
+require_relative 'gen/statement'
+require_relative 'gen/evidence'
+require_relative 'gen/sample_resources'
 
 # vim: ts=2 sw=2:
 # encoding: utf-8

data/lib/bel/gen/annotation.rb

@@ -7,7 +7,6 @@ module BEL
     # The {Annotation} module defines methods that generate random annotations
     # to be used in an evidence's {BEL::Model::ExperimentContext}.
     module Annotation
-      include BEL::Quoting
 
       # Array of the latest OpenBEL {BEL::Annotation::AnnotationDefinition}.
       ANNOTATIONS =
@@ -38,7 +37,11 @@ module BEL
 
         {
           :name  => anno.keyword,
-          :value => anno.values.keys.sample
+          :value => Rantly {
+            sized(range(5, 20)) {
+              string(/[[:alnum:]]|[[:blank:]]|[[:punct:]]/)
+            }
+          }
         }
       end
     end

data/lib/bel/gen/evidence.rb

@@ -1,8 +1,11 @@
 require 'bel'
+require_relative 'document_header'
 require_relative 'annotation'
 require_relative 'citation'
-require_relative 'bel_expression'
-require_relative 'document_header'
+require_relative 'namespace'
+require_relative 'parameter'
+require_relative 'term'
+require_relative 'statement'
 
 require_relative '../gen'
 BEL::Gen.soft_require('rantly')
@@ -15,10 +18,13 @@ module BEL
     module Evidence
 
       # Include other generators needed to create {BEL::Model::Evidence}.
+      include BEL::Gen::DocumentHeader
       include BEL::Gen::Annotation
       include BEL::Gen::Citation
-      include BEL::Gen::DocumentHeader
-      include BEL::Gen::Expression
+      include BEL::Gen::Namespace
+      include BEL::Gen::Parameter
+      include BEL::Gen::Statement
+      include BEL::Gen::Term
 
       # Returns a random {BEL::Model::Evidence}.
       #

data/lib/bel/gen/namespace.rb

@@ -0,0 +1,37 @@
+require 'bel'
+require_relative '../gen'
+BEL::Gen.soft_require('rantly')
+
+module BEL
+  module Gen
+
+    # The {Namespace} module defines methods that generate random
+    # {BEL::Namespace::NamespaceDefinition}. The generated namespace are saved
+    # and can be accessed from {Namespace#referenced_namespaces}.
+    module Namespace
+
+      # Array of the latest OpenBEL {BEL::Namespace::NamespaceDefinition}.
+      NAMESPACES = BEL::Namespace::NAMESPACE_LATEST.map { |prefix, (url, rdf_uri)|
+        BEL::Namespace::NamespaceDefinition.new(prefix, url, rdf_uri)
+      }
+
+      # Retrieve the namespaces chosen during use of {#namespace}.
+      # @return [Hash] hash of namespace prefix => {BEL::Namespace::NamespaceDefinition}
+      def referenced_namespaces
+        @referenced_namespaces ||= Hash[
+          NAMESPACES.map { |ns| [ns.prefix, ns] }
+        ]
+      end
+
+      # Returns a randomly chosen namespace.
+      # @return [BEL::Namespace::NamespaceDefinition] a random namespace
+      def namespace
+        ns = Rantly {
+          choose(*NAMESPACES)
+        }
+        referenced_namespaces[ns.prefix] = ns
+        ns
+      end
+    end
+  end
+end

data/lib/bel/gen/parameter.rb

@@ -0,0 +1,71 @@
+require 'bel'
+require_relative '../gen'
+BEL::Gen.soft_require('rantly')
+
+module BEL
+  module Gen
+
+    # The {Parameter} module defines methods that generate random BEL
+    # {BEL::Model::Parameter parameters}.
+    module Parameter
+      include BEL::Gen::Namespace
+
+      # Returns a BEL parameter from a random namespace. The value will be
+      # a random string and not necessarily part of the namespace.
+      #
+      # @return [BEL::Model::Parameter] a randomly generated parameter with
+      #         a namespace
+      def bel_parameter_with_namespace
+        ns    = namespace
+        value = Rantly.value {
+          sized(range(3,10)) {
+            string(/[[:alnum:]]|[[:blank:]]|[[:punct:]]/)
+          }
+        }
+        BEL::Model::Parameter.new(
+          ns,
+          value,
+          :A
+        )
+      end
+
+      # Returns a BEL parameter without a namespace. The value will be
+      # a random string.
+      #
+      # @return [BEL::Model::Parameter] a randomly generated parameter
+      #         without a namespace
+      def bel_parameter_without_namespace
+        value = Rantly.value {
+          sized(range(3,10)) {
+            string(/[[:alnum:]]|[[:blank:]]|[[:punct:]]/)
+          }
+        }
+        BEL::Model::Parameter.new(
+          nil,
+          value,
+          :A
+        )
+      end
+
+      # Returns a BEL parameter that may or may not have a namespace.
+      #
+      # Note: This method has a better chance of selecting a BEL parameter
+      # with a namespace.
+      #
+      # @see #bel_parameter_with_namespace
+      # @see #bel_parameter_without_namespace
+      # @return [BEL::Model::Parameter] a parameter that may or may not have
+      #         a namespace
+      def bel_parameter
+        with_namespace    = bel_parameter_with_namespace
+        without_namespace = bel_parameter_without_namespace
+        Rantly {
+          freq(
+            [5, :literal, with_namespace],
+            [1, :literal, without_namespace],
+          )
+        }
+      end
+    end
+  end
+end

data/lib/bel/gen/sample_resources.rb

@@ -0,0 +1,52 @@
+require_relative '../gen'
+BEL::Gen.soft_require('rantly')
+
+module BEL
+  module Gen
+
+    # The {SampleResources} module defines methods that sample data from actual
+    # resources.
+    #
+    # {BEL::Model::Parameter BEL parameters} are sampled from a
+    # {BEL::Namespace::NamespaceDefinition}.
+    #
+    # Annotations are sampled from a {BEL::Annotation::AnnotationDefinition}.
+    module SampleResources
+      include BEL::Gen::Annotation
+
+      # Returns a sampled annotation as a hash of +:name+ and +:value+. These
+      # can be added directly to an evidence's {BEL::Model::ExperimentContext}.
+      #
+      # @return [Hash] sampled annotation; hash of +:name+ and +:value+
+      def annotation
+        # pick annotation definition
+        anno = Rantly {
+          choose(*ANNOTATIONS)
+        }
+
+        # track annotation definitions
+        referenced_annotations[anno.keyword] = anno
+
+        {
+          :name  => anno.keyword,
+          :value => anno.values.keys.sample
+        }
+      end
+
+      # Returns a BEL parameter with a value sampled from a random namespace.
+      #
+      # @return [BEL::Model::Parameter] a parameter with value sampled from a
+      #         random namespace
+      def bel_parameter_with_namespace
+        ns    = namespace
+        value = ns.values.keys.sample
+        enc   = ns.values[value]
+        BEL::Model::Parameter.new(
+          ns,
+          value,
+          enc
+        )
+      end
+    end
+  end
+end