bel 0.5.0 → 0.6.0

data/lib/bel/translator/plugins/bel_script/evidence_serialization.rb

@@ -60,19 +60,20 @@ module BEL::Translator::Plugins::BelScript::EvidenceSerialization
 
     Hash[
       experiment_context.
-        sort_by { |obj| obj[:name] }.
+        sort_by { |obj| obj[:name].to_sym }.
         map { |obj|
-        name, value = obj.values_at(:name, :value)
+          name  = obj[:name].to_sym
+          value = obj[:value]
 
-        value_s =
-          if value.respond_to? :each
-            "{#{value.map { |v| ensure_quotes(v) }.join(', ')}}"
-          else
-            ensure_quotes(value)
-          end
+          value_s =
+            if value.respond_to? :map
+              "{#{value.map { |v| quote(v) }.join(', ')}}"
+            else
+              quote(value)
+            end
 
-        [name, value_s]
-      }
+          [name, value_s]
+        }
     ]
   end
 end

data/lib/bel/translator/plugins/bel_script/evidence_yielder.rb

@@ -13,7 +13,7 @@ module BEL::Translator::Plugins
         'Evidence' => true,
       }
 
-      def initialize(data)
+      def initialize(data, options = {})
         @data                   = data
         @references             = References.new
         @metadata               = Metadata.new
@@ -53,7 +53,7 @@ module BEL::Translator::Plugins
           if fields.respond_to? :each
             evidence.citation = Citation.new(
               fields.map { |field|
-                remove_quotes(field)
+                unquote(field)
               }.to_a
             )
           end

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

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

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

@@ -72,7 +72,7 @@ module BEL::Translator::Plugins
           EVIDENCE_ROOT => {
             :bel_statement      => hash[:bel_statement].to_s,
             :citation           => hash[:citation],
-            :summary_text       => hash[:summary_text],
+            :summary_text       => escape_newlines(hash[:summary_text]),
             :experiment_context => hash[:experiment_context],
             :references         => hash[:references],
             :metadata           => hash[:metadata].to_a
@@ -101,6 +101,10 @@ module BEL::Translator::Plugins
           obj.is_a? ::BEL::Model::Statement
         }.first
       end
+
+      def escape_newlines(value)
+        value.gsub(/\n/, "\\n").gsub(/\r/, "\\r")
+      end
     end
   end
 end

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

@@ -34,6 +34,10 @@ module BELRDF
     end
 
     def to_rdf(graph_name = nil)
+      # resolve encoding to make rdf:type assertions
+      if !@enc && @ns.is_a?(BEL::Namespace::NamespaceDefinition)
+        @enc = @ns[@value].enc
+      end
       uri = to_uri
       encodings = ['A'].concat(@enc.to_s.each_char.to_a).uniq
       encodings.map! { |enc| concept_statement(enc, uri, graph_name)}

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

@@ -193,19 +193,10 @@ module BEL::Translator::Plugins
 
       def start_parameter(attributes)
         if stack_top == :term
-          ns_id              = attr_value(attributes, NS)
-          # XXX Hitting a SystemStackError on line 174 (inside call).
-          # Example: large_corpus.xbel
-          ns_sym = ns_id.to_sym
-          namespace_reference = @evidence.references.namespaces.find { |ns|
-            ns[:keyword] == ns_sym
-          }
           ns =
-            if namespace_reference
-              {
-                :prefix => namespace_reference[:keyword],
-                :url    => namespace_reference[:uri]
-              }
+            if has_attr?(attributes, NS)
+              ns_id = attr_value(attributes, NS)
+              namespace_reference(ns_id, @evidence)
             else
               nil
             end
@@ -479,6 +470,26 @@ module BEL::Translator::Plugins
       def attr_value(attributes, attr_name)
         attributes["bel:#{attr_name}"]
       end
+
+      def has_attr?(attributes, attr_name)
+        attributes.has_key?("bel:#{attr_name}")
+      end
+
+      def namespace_reference(ns_id, evidence)
+        ns_id = ns_id.to_sym
+        namespace_reference = evidence.references.namespaces.find { |ns|
+          ns[:keyword] == ns_id
+        }
+
+        if namespace_reference
+          {
+            :prefix => namespace_reference[:keyword],
+            :url    => namespace_reference[:uri]
+          }
+        else
+          nil
+        end
+      end
     end
   end
 end

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

@@ -7,7 +7,7 @@ module BEL::Translator::Plugins
 
     class EvidenceYielder
 
-      def initialize(io)
+      def initialize(io, options = {})
         @io = io
       end
 

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

@@ -10,23 +10,23 @@ module BEL::Translator::Plugins
       include ::BEL::Translator
 
       def read(data, options = {})
-        EvidenceYielder.new(data)
+        EvidenceYielder.new(data, options)
       end
 
       def write(objects, writer = StringIO.new, options = {})
         if block_given?
-          XBELYielder.new(objects).each { |xml_data|
+          XBELYielder.new(objects, options).each { |xml_data|
             yield xml_data
           }
         else
           if writer
-            XBELYielder.new(objects).each { |xml_data|
+            XBELYielder.new(objects, options).each { |xml_data|
               writer << xml_data
               writer.flush
             }
             writer
           else
-            XBELYielder.new(objects)
+            XBELYielder.new(objects, options)
           end
         end
       end

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

@@ -10,11 +10,28 @@ module BEL::Translator::Plugins
       FUNCTIONS = ::BEL::Language::FUNCTIONS
 
       def initialize(data, options = {})
-        @data         = data
+        @data                     = data
+        @annotation_reference_map = options.fetch(:annotation_reference_map, nil)
+        @namespace_reference_map  = options.fetch(:namespace_reference_map, nil)
       end
 
       def each
         if block_given?
+          combiner =
+            if @streaming
+              BEL::Model::StreamingEvidenceCombiner.new(@data)
+            elsif @annotation_reference_map && @namespace_reference_map
+              BEL::Model::MapReferencesCombiner.new(
+                @data,
+                BEL::Model::HashMapReferences.new(
+                  @annotation_reference_map,
+                  @namespace_reference_map
+                )
+              )
+            else
+              BEL::Model::BufferingEvidenceCombiner.new(@data)
+            end
+
           header_flag = true
 
           # yield <document>
@@ -23,7 +40,7 @@ module BEL::Translator::Plugins
 
           el_statement_group = nil
           evidence_count = 0
-          @data.each { |evidence|
+          combiner.each { |evidence|
             if header_flag
               # document header
               el_statement_group = XBELYielder.statement_group
@@ -32,10 +49,10 @@ module BEL::Translator::Plugins
                 XBELYielder.header(evidence.metadata.document_header)
               )
               yield element_string(
-                XBELYielder.namespace_definitions(evidence.references.namespaces)
+                XBELYielder.namespace_definitions(combiner.namespace_references)
               )
               yield element_string(
-                XBELYielder.annotation_definitions(evidence.references.annotations)
+                XBELYielder.annotation_definitions(combiner.annotation_references)
               )
 
               yield start_element_string(el_statement_group)
@@ -330,11 +347,11 @@ module BEL::Translator::Plugins
       def self.namespace_definitions(list)
         el_nd = REXML::Element.new('bel:namespaceGroup')
         list.each do |namespace|
-          keyword, uri     = namespace.values_at(:keyword, :uri).map(&:to_s)
-          el               = REXML::Element.new('bel:namespace')
+          keyword, uri = namespace.values_at(:keyword, :uri).map(&:to_s)
+          el           = REXML::Element.new('bel:namespace')
+
           el.add_attribute 'bel:prefix', keyword
           el.add_attribute 'bel:resourceLocation', uri
-
           el_nd.add_element(el)
         end
 

data/lib/bel/util.rb

@@ -19,28 +19,33 @@ module BEL
   # (e.g. lung disease|O) and a database value identifier for a BEL annotation
   # file (e.g. lung|UBERON_0002048).
   def self.read_resource(url)
-    resource_lines = BEL::read_lines(url)
-
-    # Drop until the delimiter line and extract the delimiter, e.g.
-    # DelimiterString=|
-    delimiter_line = resource_lines.take(100).find { |l| l.start_with?("DelimiterString") }
-    delimiter =
-      if delimiter_line
-        delimiter_line.strip.split('=')[1]
-      else
-        DEFAULT_RESOURCE_VALUE_DELIMITER
-      end
+    @@url_content_cache ||= {}
+    @@url_content_cache.fetch(url) {
+      resource_lines = BEL::read_lines(url)
+
+      # Drop until the delimiter line and extract the delimiter, e.g.
+      # DelimiterString=|
+      delimiter_line = resource_lines.take(100).find { |l| l.start_with?("DelimiterString") }
+      delimiter =
+        if delimiter_line
+          delimiter_line.strip.split('=')[1]
+        else
+          DEFAULT_RESOURCE_VALUE_DELIMITER
+        end
 
-    # Extract namespace values based on the delimiter.
-    Hash[
-      resource_lines.
-      drop_while { |l| !l.start_with?("[Values]") }.
-      drop(1).
-      map { |s|
-        val_enc = s.strip!.split(delimiter).map(&:to_sym)
-        val_enc[0..1]
-      }
-    ]
+      # Extract resource values based on the delimiter.
+      resource_values = Hash[
+        resource_lines.
+        drop_while { |l| !l.start_with?("[Values]") }.
+        drop(1).
+        map { |s|
+          val_enc = s.strip!.split(delimiter).map(&:to_sym)
+          val_enc[0..1]
+        }
+      ]
+      @@url_content_cache[url] = resource_values
+      resource_values
+    }
   end
 
   def self.read_all(reference, options = {})
@@ -76,6 +81,35 @@ module BEL
     end
   end
 
+  def self.keys_to_symbols(obj)
+    self.object_convert(:key, obj) { |key| key.to_sym }
+  end
+
+  def self.object_convert(type, source, &block)
+    case source
+    when Array
+      source.inject([]) { |new, v|
+        new << object_convert(type, v, &block)
+        new
+      }
+    when Hash
+      source.inject({}) { |new, (k,v)|
+        if type == :key || k.is_a?(type)
+          k = block.call(k)
+        end
+
+        new[k] = object_convert(type, v, &block)
+        new
+      }
+    else
+      if type != :key && source.is_a?(type)
+        block.call(source)
+      else
+        source
+      end
+    end
+  end
+
   # PRIVATE
 
   def self.multi_open(reference, options = {})

data/lib/bel/version.rb

@@ -1,3 +1,3 @@
 module BEL
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bel
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Anthony Bargnesi
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-10 00:00:00.000000000 Z
+date: 2016-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -82,18 +82,28 @@ files:
 - lib/bel/evidence_model/bel_parameter.rb
 - lib/bel/evidence_model/bel_statement.rb
 - lib/bel/evidence_model/bel_term.rb
+- lib/bel/evidence_model/buffering_evidence_combiner.rb
 - lib/bel/evidence_model/citation.rb
 - lib/bel/evidence_model/evidence.rb
 - lib/bel/evidence_model/experiment_context.rb
+- lib/bel/evidence_model/hash_map_references.rb
+- lib/bel/evidence_model/map_references.rb
+- lib/bel/evidence_model/map_references_combiner.rb
 - lib/bel/evidence_model/metadata.rb
 - lib/bel/evidence_model/references.rb
+- lib/bel/evidence_model/streaming_evidence_combiner.rb
 - lib/bel/evidence_model/summary_text.rb
+- lib/bel/evidence_model/util.rb
 - lib/bel/gen.rb
 - lib/bel/gen/annotation.rb
-- lib/bel/gen/bel_expression.rb
 - lib/bel/gen/citation.rb
 - lib/bel/gen/document_header.rb
 - lib/bel/gen/evidence.rb
+- lib/bel/gen/namespace.rb
+- lib/bel/gen/parameter.rb
+- lib/bel/gen/sample_resources.rb
+- lib/bel/gen/statement.rb
+- lib/bel/gen/term.rb
 - lib/bel/json.rb
 - lib/bel/json/adapter/multi_json.rb
 - lib/bel/json/adapter/oj.rb

data/lib/bel/gen/bel_expression.rb

@@ -1,128 +0,0 @@
-require 'bel'
-require_relative '../gen'
-BEL::Gen.soft_require('rantly')
-
-module BEL
-  module Gen
-
-    # The {Expression} module defines methods that generate random BEL
-    # {BEL::Model::Parameter parameters}, {BEL::Model::Term terms}, and
-    # {BEL::Model::Statement statements}.
-    module Expression
-      include BEL::Quoting
-
-      # 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)
-                      }
-
-      # Array of all BEL 1.0 functions including both short and long form.
-      FUNCTIONS     = BEL::Language::FUNCTIONS.map { |_, fx|
-                        [ fx[:short_form], fx[:long_form] ]
-                      }.flatten.sort.uniq
-
-      # Array of all BEL 1.0 relationships including both short and long form.
-      RELATIONSHIPS = BEL::Language::RELATIONSHIPS.each.to_a.flatten.sort.uniq
-
-      # 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
-
-      # Returns a BEL parameter from a random namespace. The value will be
-      # randomly sample from the chosen namespace.
-      #
-      # @return [BEL::Model::Parameter] a parameter chosen from a namespace
-      def bel_parameter_with_namespace
-        ns    = namespace
-        value = ns.values.keys.sample
-        enc   = ns.values[value]
-        BEL::Model::Parameter.new(
-          ns,
-          value.to_s,
-          enc
-        )
-      end
-
-      # Returns a BEL parameter without a namespace. The value will be
-      # a random string.
-      #
-      # @return [BEL::Model::Parameter] a 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
-      # from 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
-
-      # Returns a randomly chosen function.
-      # @return [Symbol] the function label (short or long form)
-      def function
-        Rantly {
-          choose(*FUNCTIONS)
-        }
-      end
-
-      # Returns a randomly chosen relationship.
-      # @return [Symbol] the relationship label (short or long form)
-      def relationship
-        Rantly {
-          choose(*RELATIONSHIPS)
-        }
-      end
-
-      # Returns a randomly constructed BEL term.
-      # @return [String] the term label
-      def bel_term
-        "#{function}(#{bel_parameter})"
-      end
-
-      # Returns a randomly constructed BEL statement.
-      # @return [String] the statement label
-      def bel_statement
-        sub = bel_term
-        obj = bel_term
-        "#{sub} #{relationship} #{obj}"
-      end
-    end
-  end
-end