bel_parser 1.0.0.alpha.20 → 1.0.0.alpha.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5f5c683930e9f6671b818ec184fc5a8a35231984
-  data.tar.gz: 04cb98ee13e3c6f57f2c9ea3a6b2188aba861918
+  metadata.gz: d6a168817ba0f0cede0a3b4c7fdd078514a8ee6f
+  data.tar.gz: 84bb8cded6070abe5f02e93703c149cbb3adfd88
 SHA512:
-  metadata.gz: 362bc4fd38cb8cb60fcbf3c6a975671192258a9717101b53dd536e68e912d4af15f9c4620506f9782e2cefcab5fbf450586fc988a422e2710a1e8b6e273d41c1
-  data.tar.gz: 6034289be41223dcda961ddafccc4079b62502ab3d4c8376eddee9bc7af109344cc16c2b442a9c4a6aac37186948f530875d3a7275da21bdc1408e5f1d8a5fa3
+  metadata.gz: b6960ba1eb867c53e98ea37be80617c7521773bd8676e348b1165a7ecf598acf9b6d005147423601b449c446638644cc130afec39856714b4ff70ac92b848f5e
+  data.tar.gz: 516482702677227cfdcb88aa44de29ea0a6ca3f00f1da74ad7e4ca3cfd6773d7df765e715b18e72a5e9a92845e05b1c5a2fdac1e52362d0a374073e75c24eff4

data/.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
                                  'Anthony Bargnesi',
                                  'Nick Bargnesi',
                                ]
-  spec.date                  = %q{2016-05-01}
+  spec.date                  = %q{2016-05-02}
   spec.email                 = %q{abargnesi@selventa.com}
   spec.files                 = [
                                  Dir.glob('lib/**/*.{rb,rl}'),

data/VERSION

@@ -1 +1 @@
-1.0.0.alpha.20
+1.0.0.alpha.21

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

@@ -0,0 +1,125 @@
+require_relative 'evidence_serialization.rb'
+
+# BEL Script evidence serialization that groups evidence by citation scoped to
+# individual statement groups (i.e. BEL Script's +SET STATEMENT_GROUP+ and
+# +UNSET STATEMENT_GROUP+).
+#
+# @example Citation serialization for a group of evidence
+#   SET STATEMENT_GROUP = 12857727
+#   SET Citation = {"PubMed", "Journal...", "12857727", "2003-08-11", "", ""}
+#   SET Evidence = "USF1 and USF2 bound the IGF2R promoter in vitro, ..."
+#   SET CellLine = "MCF 10A"
+#   SET TextLocation = Abstract
+#   complex(p(HGNC:USF1),g(HGNC:IGF2R))
+#
+#   complex(p(HGNC:USF2),g(HGNC:IGF2R))
+#
+#   tscript(p(HGNC:USF2)) directlyIncreases r(HGNC:IGF2R)
+#
+#   tscript(p(HGNC:USF1)) causesNoChange r(HGNC:IGF2R)
+#
+#   SET Evidence = "c-Myc was present on the CDK4 promoter to the ..."
+#   complex(p(HGNC:MYC),g(HGNC:CDK4))
+#   UNSET STATEMENT_GROUP
+module BEL::Translator::Plugins::BelScript::BelCitationSerialization
+  include BEL::Translator::Plugins::BelScript::EvidenceSerialization
+
+  # Serialize the {BEL::Model::Evidence evidence} to a BEL Script string.
+  #
+  # Includes +SET AnnotationName+ and +UNSET AnnotationName+ where needed in
+  # order to remove duplicating annotations.
+  #
+  # @param  [BEL::Model::Evidence] evidence the evidence to serialize
+  # @return [String]               the BEL Script string
+  def to_bel(evidence)
+    bel = ''
+
+    citation     = citation_value(evidence)
+    summary_text = summary_text_value(evidence)
+    annotations  = annotation_values(evidence)
+
+    current_annotations            = {}.merge(annotations)
+    current_annotations[:Citation] = citation if citation
+    current_annotations[:Evidence] = summary_text if summary_text
+
+    if !evidence.citation.id || evidence.citation.id.empty?
+      citation_id = quote('')
+    else
+      citation_id = quote_if_needed(evidence.citation.id)
+    end
+
+    # Reset cumulative annotations if new citation.
+    if cumulative_citation == nil
+      bel << %Q{SET STATEMENT_GROUP = #{citation_id}\n}
+      cumulative_annotations.clear
+    elsif evidence.citation != cumulative_citation
+      bel << %Q{UNSET STATEMENT_GROUP\n}
+      bel << "\n\n"
+      bel << %Q{SET STATEMENT_GROUP = #{citation_id}\n}
+      cumulative_annotations.clear
+    end
+
+    # Hang on to the last citation.
+    self.cumulative_citation = evidence.citation
+
+    # UNSET unused annotations from previous evidence.
+    (cumulative_annotations.keys - current_annotations.keys).each do |unset_key|
+      bel << "UNSET #{unset_key}\n"
+      cumulative_annotations.delete(unset_key)
+    end
+
+    # Remove annotation if key/value was SET by a previous evidence.
+    Hash[
+      cumulative_annotations.to_a & current_annotations.to_a
+    ].each do |same_k, _|
+      current_annotations.delete(same_k)
+    end
+
+    # Retain the current evidence's annotation in cumulative set.
+    cumulative_annotations.merge!(current_annotations)
+
+    # SET Citation
+    citation = current_annotations.delete(:Citation)
+    if citation
+      bel << "SET Citation = {#{citation}}\n"
+    end
+
+    # SET Evidence
+    summary_text = current_annotations.delete(:Evidence)
+    if summary_text
+      bel << %Q{SET Evidence = "#{summary_text}"\n}
+    end
+
+    # SET new or modified annotations
+    current_annotations.sort.each do |(name, value)|
+      bel << "SET #{name} = #{value}\n"
+    end
+
+    # Assert BEL statement
+    bel << "#{evidence.bel_statement}\n"
+
+    # Separate evidence by new line.
+    bel << "\n"
+
+    bel
+  end
+
+  private
+
+  # The cumulative citation that is active for the current evidence. This is
+  # tracked in order to decide when to begin a new statement group.
+  attr_accessor :cumulative_citation
+
+  # Returns the cumulative +Hash+ of annotations. This *state* is used to keep
+  # track of the active, scoped annotations as evidence is serialized.
+  def cumulative_annotations
+    @cumulative_annotations ||= {}
+  end
+
+  # Return BEL Script syntax that should completes the BEL Script document.
+  # For Citation serialization we will always end with the unset of a
+  # statement group.
+  def epilogue
+    %Q{UNSET STATEMENT_GROUP\n}
+  end
+end

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

@@ -0,0 +1,109 @@
+require_relative 'evidence_serialization'
+
+# BEL Script evidence serialization that writes each evidence with their full
+# set of annotations (i.e. includes all `SET` and necessary `UNSET` records).
+# This style is more readable because it groups all set annotations near the
+# BEL statement.
+#
+# @example Discrete serialization for a group of evidence
+#   SET Citation = {"PubMed", "Journal...", "12857727", "2003-08-11", "", ""}
+#   SET Evidence = "USF1 and USF2 bound the IGF2R promoter in vitro, ..."
+#   SET CellLine = "MCF 10A"
+#   SET TextLocation = Abstract
+#   complex(p(HGNC:USF1),g(HGNC:IGF2R))
+#
+#   SET Citation = {"PubMed", "Journal...", "12857727", "2003-08-11", "", ""}
+#   SET Evidence = "USF1 and USF2 bound the IGF2R promoter in vitro, ..."
+#   SET CellLine = "MCF 10A"
+#   SET TextLocation = Abstract
+#   complex(p(HGNC:USF2),g(HGNC:IGF2R))
+#
+#   SET Citation = {"PubMed", "Journal...", "12857727", "2003-08-11", "", ""}
+#   SET Evidence = "USF1 and USF2 bound the IGF2R promoter in vitro, ..."
+#   SET CellLine = "MCF 10A"
+#   SET TextLocation = Abstract
+#   tscript(p(HGNC:USF2)) directlyIncreases r(HGNC:IGF2R)
+#
+#   SET Citation = {"PubMed", "Journal...", "12857727", "2003-08-11", "", ""}
+#   SET Evidence = "USF1 and USF2 bound the IGF2R promoter in vitro, ..."
+#   SET CellLine = "MCF 10A"
+#   SET TextLocation = Abstract
+#   tscript(p(HGNC:USF1)) causesNoChange r(HGNC:IGF2R)
+#
+#   SET Citation = {"PubMed", "Journal...", "12857727", "2003-08-11", "", ""}
+#   SET Evidence = "c-Myc was present on the CDK4 promoter to the ..."
+#   SET CellLine = "MCF 10A"
+#   SET TextLocation = Abstract
+#   complex(p(HGNC:MYC),g(HGNC:CDK4))
+#
+#   UNSET CellLine
+module BEL::Translator::Plugins::BelScript::BelDiscreteSerialization
+  include BEL::Translator::Plugins::BelScript::EvidenceSerialization
+
+  # Serialize the {BEL::Model::Evidence evidence} to a BEL Script string.
+  # Includes all necessary +SET AnnotationName+ and +UNSET AnnotationName+
+  # records around the BEL statement.
+  #
+  # @param  [BEL::Model::Evidence] evidence the evidence to serialize
+  # @return [String]               the BEL Script string
+  def to_bel(evidence)
+    bel = ''
+
+    citation     = citation_value(evidence)
+    summary_text = summary_text_value(evidence)
+    annotations  = annotation_values(evidence)
+
+    current_annotations            = {}.merge(annotations)
+    current_annotations[:Citation] = citation if citation
+    current_annotations[:Evidence] = summary_text if summary_text
+
+    # UNSET unused annotations from previous evidence.
+    (cumulative_annotations.keys - current_annotations.keys).each do |unset_key|
+      bel << "UNSET #{unset_key}\n"
+      cumulative_annotations.delete(unset_key)
+    end
+
+    # Retain the current evidence's annotation in cumulative set.
+    cumulative_annotations.merge!(current_annotations)
+
+    # SET Citation
+    citation = current_annotations.delete(:Citation)
+    if citation
+      bel << "SET Citation = {#{citation}}\n"
+    end
+
+    # SET Evidence
+    summary_text = current_annotations.delete(:Evidence)
+    if summary_text
+      bel << %Q{SET Evidence = "#{summary_text}"\n}
+    end
+
+    # SET new or modified annotations
+    current_annotations.sort.each do |(name, value)|
+      bel << "SET #{name} = #{value}\n"
+    end
+
+    # Assert BEL statement
+    bel << "#{evidence.bel_statement}\n"
+
+    # Separate evidence by new line.
+    bel << "\n"
+
+    bel
+  end
+
+  private
+
+  # Returns the cumulative +Hash+ of annotations. This *state* is used to keep
+  # track of the active, scoped annotations as evidence is serialized.
+  def cumulative_annotations
+    @cumulative_annotations ||= {}
+  end
+
+  # Return BEL Script syntax that completes the BEL Script document.
+  # The empty string is returned since no ending syntax is necessary when
+  # serializing each evidence discretely.
+  def epilogue
+    ""
+  end
+end

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

@@ -0,0 +1,100 @@
+require_relative 'evidence_serialization.rb'
+
+# BEL Script evidence serialization that writes evidence sequentially while
+# including only the necessary unsetting of annotations (i.e. BEL Script's
+# +UNSET AnnotationName+ syntax).
+#
+# @example Top-down serialization for a group of evidence
+#   SET Citation = {"PubMed", "Journal...", "12857727", "2003-08-11", "", ""}
+#   SET Evidence = "USF1 and USF2 bound the IGF2R promoter in vitro, ..."
+#   SET CellLine = "MCF 10A"
+#   SET TextLocation = Abstract
+#   complex(p(HGNC:USF1),g(HGNC:IGF2R))
+#
+#   complex(p(HGNC:USF2),g(HGNC:IGF2R))
+#
+#   tscript(p(HGNC:USF2)) directlyIncreases r(HGNC:IGF2R)
+#
+#   tscript(p(HGNC:USF1)) causesNoChange r(HGNC:IGF2R)
+#
+#   SET Evidence = "c-Myc was present on the CDK4 promoter to the ..."
+#   complex(p(HGNC:MYC),g(HGNC:CDK4))
+#
+#   UNSET CellLine
+module BEL::Translator::Plugins::BelScript::BelTopDownSerialization
+  include BEL::Translator::Plugins::BelScript::EvidenceSerialization
+
+  # Serialize the {BEL::Model::Evidence evidence} to a BEL Script string.
+  # Includes all necessary +SET AnnotationName+ and +UNSET AnnotationName+
+  # records within the scope of a citation's statement group.
+  #
+  # @param  [BEL::Model::Evidence] evidence the evidence to serialize
+  # @return [String]               the BEL Script string
+  def to_bel(evidence)
+    bel = ''
+
+    citation     = citation_value(evidence)
+    summary_text = summary_text_value(evidence)
+    annotations  = annotation_values(evidence)
+
+    current_annotations            = {}.merge(annotations)
+    current_annotations[:Citation] = citation if citation
+    current_annotations[:Evidence] = summary_text if summary_text
+
+    # UNSET unused annotations from previous evidence.
+    (cumulative_annotations.keys - current_annotations.keys).each do |unset_key|
+      bel << "UNSET #{unset_key}\n"
+      cumulative_annotations.delete(unset_key)
+    end
+
+    # Remove annotation if key/value was SET by a previous evidence.
+    Hash[
+      cumulative_annotations.to_a & current_annotations.to_a
+    ].each do |same_k, _|
+      current_annotations.delete(same_k)
+    end
+
+    # Retain the current evidence's annotation in cumulative set.
+    cumulative_annotations.merge!(current_annotations)
+
+    # SET Citation
+    citation = current_annotations.delete(:Citation)
+    if citation
+      bel << "SET Citation = {#{citation}}\n"
+    end
+
+    # SET Evidence
+    summary_text = current_annotations.delete(:Evidence)
+    if summary_text
+      bel << %Q{SET Evidence = "#{summary_text}"\n}
+    end
+
+    # SET new or modified annotations
+    current_annotations.sort.each do |(name, value)|
+      bel << "SET #{name} = #{value}\n"
+    end
+
+    # Assert BEL statement
+    bel << "#{evidence.bel_statement}\n"
+
+    # Separate evidence by new line.
+    bel << "\n"
+
+    bel
+  end
+
+  private
+
+  # Returns the cumulative +Hash+ of annotations. This *state* is used to keep
+  # track of the active, scoped annotations as evidence is serialized.
+  def cumulative_annotations
+    @cumulative_annotations ||= {}
+  end
+
+  # Return BEL Script syntax that completes the BEL Script document.
+  # The empty string is returned since no ending syntax is necessary when
+  # serializing in a top-down manner.
+  def epilogue
+    ""
+  end
+end

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

@@ -0,0 +1,79 @@
+require 'bel/quoting'
+
+# Serializing of common {BEL::Model::Evidence evidence} components to BEL
+# Script syntax.
+#
+# @abstract
+module BEL::Translator::Plugins::BelScript::EvidenceSerialization
+  include BEL::Quoting
+
+  # Serialize the {BEL::Model::Evidence evidence} to a BEL Script string.
+  #
+  # @param  [BEL::Model::Evidence] evidence the evidence to serialize
+  # @return [String]               the BEL Script string
+  # @abstract Include and override {#to_bel} to implement serialization
+  #           {BEL::Model::Evidence evidence} to BEL Script
+  def to_bel(evidence)
+  end
+
+  # Return BEL Script syntax that completes the BEL Script document.
+  #
+  # @abstract
+  def epilogue
+    raise NotImplementedError.new("#{self.class}#epilogue")
+  end
+
+  protected
+
+  def citation_value(evidence)
+    citation = evidence.citation
+
+    return nil unless citation && citation.valid?
+
+    values = citation.to_a
+    values.map! { |v|
+      v ||= ""
+      if v.respond_to?(:each)
+        %Q{"#{v.join('|')}"}
+      else
+        %Q{"#{v}"}
+      end
+    }
+    values.join(', ')
+  end
+
+  def summary_text_value(evidence)
+    summary_text = evidence.summary_text
+
+    return nil unless summary_text && summary_text.value
+
+    value = summary_text.value
+    value.gsub!("\n", "")
+    value.gsub!('"', %Q{\\"})
+    value
+  end
+
+  def annotation_values(evidence)
+    experiment_context = evidence.experiment_context
+
+    return {} unless experiment_context
+
+    Hash[
+      experiment_context.
+        sort_by { |obj| obj[:name].to_sym }.
+        map { |obj|
+          name  = obj[:name].to_sym
+          value = obj[:value]
+
+          value_s =
+            if value.respond_to? :map
+              "{#{value.map { |v| quote(v) }.join(', ')}}"
+            else
+              quote(value)
+            end
+
+          [name, value_s]
+        }
+    ]
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'bel_parser'
+require 'bel_parser/resource/resource_url_reader'
+require 'bel/evidence_model'
+
+module BEL::Translator::Plugins
+  module BelScript
+    class Reader
+      include ::BELParser::Script
+
+      def initialize(io)
+        @io    = io
+        @state = {
+          resource_reader: BELParser::Resource::ResourceURLReader.new(true),
+          specification: BELParser::Language.specification('2.0'),
+          namespace_definitions: {}
+        }
+      end
+
+      def each
+        if block_given?
+          NanopubMapper.new(
+            Validator.new(
+              StateAggregator.new(
+                FirstNode.new(Filter.new(BELParser::ASTGenerator.new(@io))),
+                @state))).each do |hash|
+                  yield ::BEL::Model::Evidence.create(hash)
+                end
+        else
+          enum_for(:each)
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,8 @@
 # Requires the "bel" gem.
 # This is for the BelScript translator intended to be plugged into bel.rb.
 require 'bel/translator'
+require_relative 'reader'
+require_relative 'writer'
 
 module BEL::Translator::Plugins
   module BelScript
@@ -10,25 +12,25 @@ module BEL::Translator::Plugins
       include ::BEL::Translator
 
       def read(data, options = {})
-        # EvidenceYielder.new(data, options)
+        Reader.new(data)
       end
 
       def write(objects, writer = StringIO.new, options = {})
-        # if block_given?
-        #   BelYielder.new(objects, options).each { |bel_part|
-        #     yield bel_part
-        #   }
-        # else
-        #   if writer
-        #     BelYielder.new(objects, options).each { |bel_part|
-        #       writer << "#{bel_part}"
-        #       writer.flush
-        #     }
-        #     writer
-        #   else
-        #     BelYielder.new(objects, options)
-        #   end
-        # end
+        if block_given?
+          Writer.new(objects, options).each { |bel_part|
+            yield bel_part
+          }
+        else
+          if writer
+            Writer.new(objects, options).each { |bel_part|
+              writer << "#{bel_part}"
+              writer.flush
+            }
+            writer
+          else
+            Writer.new(objects, options)
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,180 @@
+require_relative 'bel_citation_serialization'
+require_relative 'bel_discrete_serialization'
+require_relative 'bel_top_down_serialization'
+require 'bel'
+
+module BEL::Translator::Plugins
+
+  module BelScript
+
+    class Writer
+
+      # Create a {Writer} object that serializes {BEL::Model::Evidence} to
+      # BEL Script.
+      #
+      # @param [Enumerator<BEL::Model::Evidence>] data evidence data iterated
+      #        using +each+
+      # @option options [Boolean] :write_header +true+ to write the BEL Script
+      #         document header; +false+ to not write the BEL Script document
+      #         header
+      # @option options [Symbol,Module] :serialization the serialization
+      #         technique to use for evidence; a +Module+ type will be used as
+      #         is; a +Symbol+ type will be mapped as
+      #         +:discrete+ => {BelDiscreteSerialization},
+      #         +:topdown+ => {BelTopDownSerialization},
+      #         +:citation+ => {BelCitationSerialization}; otherwise the default
+      #         of {BelCitationSerialization} is used
+      def initialize(data, options = {})
+        @data                     = data
+        @streaming                = options.fetch(:streaming, false)
+        @write_header             = options.fetch(:write_header, true)
+        @annotation_reference_map = options.fetch(:annotation_reference_map, nil)
+        @namespace_reference_map  = options.fetch(:namespace_reference_map, nil)
+
+        # augment self with BEL serialization stategy.
+        serialization = options[:serialization]
+        serialization_module =
+          case serialization
+          when Module
+            serialization
+          when String, Symbol
+            serialization_refs = {
+              :discrete => BelDiscreteSerialization,
+              :topdown  => BelTopDownSerialization,
+              :citation => BelCitationSerialization,
+            }
+            serialization_module = serialization_refs[serialization.to_sym]
+            unless serialization_module
+                raise %Q{No BEL serialization strategy for "#{serialization}"}
+            end
+            serialization_module
+          else
+            # Default to citation serialization.
+            BelCitationSerialization
+          end
+
+        self_eigenclass = (class << self; self; end)
+        self_eigenclass.send(:include, serialization_module)
+      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
+          combiner.each { |evidence|
+
+            # serialize evidence
+            bel = to_bel(evidence)
+
+            if @write_header && header_flag
+              yield document_header(evidence.metadata.document_header)
+              yield namespaces(combiner.namespace_references)
+              yield annotations(combiner.annotation_references)
+
+              yield <<-COMMENT.gsub(/^\s+/, '')
+                ###############################################
+                # Statements Section
+              COMMENT
+              header_flag = false
+            end
+
+            yield bel
+          }
+
+          yield epilogue
+        else
+          to_enum(:each)
+        end
+      end
+
+      private
+
+      def document_header(header)
+        return "" unless header
+
+        bel = <<-COMMENT.gsub(/^\s+/, '')
+          ###############################################
+          # Document Properties Section
+        COMMENT
+
+        header.each { |name, value|
+          name_s  = name.to_s
+          value_s =
+            if value.respond_to?(:each)
+              value.join('|')
+            else
+              value.to_s
+            end
+
+          # handle casing for document properties (special case, contactinfo)
+          name_s = (name_s.downcase == 'contactinfo') ?
+            'ContactInfo' :
+            name_s.capitalize
+
+          bel << %Q{SET DOCUMENT #{name_s} = "#{value_s}"\n}
+        }
+
+        bel << "\n"
+        bel
+      end
+
+      def annotations(annotation_references)
+        bel = <<-COMMENT.gsub(/^\s+/, '')
+          ###############################################
+          # Annotation Definitions Section
+        COMMENT
+
+        return bel unless annotation_references
+
+        annotation_references.reduce(bel) { |bel, ref|
+          keyword, type, domain = ref.values_at(:keyword, :type, :domain)
+          bel << "DEFINE ANNOTATION #{keyword} AS "
+
+          case type.to_sym
+          when :uri
+            bel << %Q{URL "#{domain}"\n}
+          when :pattern
+            regex = domain.respond_to?(:source) ? domain.source : domain
+            bel << %Q{PATTERN "#{regex}"\n}
+          when :list
+            bel << %Q|LIST {#{domain.inspect[1...-1]}}\n|
+          end
+          bel
+        }
+        bel << "\n"
+        bel
+      end
+
+      def namespaces(namespace_references)
+        bel = <<-COMMENT.gsub(/^\s+/, '')
+          ###############################################
+          # Namespace Definitions Section
+        COMMENT
+
+        return bel unless namespace_references
+
+        namespace_references.reduce(bel) { |bel, ref|
+          keyword, url = ref.values_at(:keyword, :uri)
+          bel << %Q{DEFINE NAMESPACE #{keyword} AS URL "#{url}"\n}
+          bel
+        }
+        bel << "\n"
+        bel
+      end
+    end
+  end
+end

data/lib/bel_parser/resource/resource_url_reader.rb

@@ -19,12 +19,16 @@ module BELParser
     class ResourceURLReader
       include Reader
 
+      # Class ivars for tracking open {GDBM} databases.
+      @dataset_file   = nil
+      @resource_files = {}
+
       DEFAULT_RESOURCE_VALUE_DELIMITER = '|'
       private_constant :DEFAULT_RESOURCE_VALUE_DELIMITER
 
       def initialize(reuse_database_files = false)
         @resources = {}
-        @datasets  = ::GDBM.new(_temporary_datasets_file)
+        @datasets  = ResourceURLReader.open_datasets_file
         @reuse     = reuse_database_files
       end
 
@@ -67,15 +71,14 @@ module BELParser
       def create_resource(url, line_enum)
         delimiter           = DEFAULT_RESOURCE_VALUE_DELIMITER
         dataset             = @datasets[url]
-        value_database_file = _temporary_database_file(url)
-        values              = ::GDBM.new(value_database_file)
+        values              = ResourceURLReader.open_resource_file(url)
 
         if @reuse && dataset && values.size > 0
           warn(
             <<-MSG.gsub(/^ {14}/, '')
               Warning - Reusing value database.
                 URL:  #{url}
-                File: #{value_database_file}
+                File: #{ResourceURLReader._temporary_resource_file(url)}
             MSG
           )
           return {
@@ -130,31 +133,41 @@ module BELParser
         end
       end
 
-      private
-
-      def _get(url, &block)
-        Net::HTTP.start(url.host, url.port) do |http|
-          http.request(Net::HTTP::Get.new(url)) do |response|
-            return response.read_body
-          end
-        end
+      def self.open_datasets_file
+        @dataset_file ||= ::GDBM.new(_temporary_datasets_file)
       end
 
-      def _hash_url(url)
-        Base64.encode64(Digest::SHA1.digest(url)).delete("/=\n")
+      def self.open_resource_file(url)
+        @resource_files[url] ||= ::GDBM.new(_temporary_resource_file(url))
       end
 
-      def _temporary_datasets_file
+      def self._temporary_datasets_file
         resource_directory = File.join(Dir.tmpdir, 'belresources')
         FileUtils.mkdir_p(resource_directory)
         File.join(resource_directory, 'datasets.gdbm')
       end
 
-      def _temporary_database_file(url)
+      def self._temporary_resource_file(url)
         resource_directory = File.join(Dir.tmpdir, 'belresources')
         FileUtils.mkdir_p(resource_directory)
         File.join(resource_directory, "#{_hash_url(url)}.gdbm")
       end
+
+      def self._hash_url(url)
+        Base64.encode64(Digest::SHA1.digest(url)).delete("/=\n")
+      end
+      private_class_method :_hash_url
+
+      private
+
+      def _get(url, &block)
+        Net::HTTP.start(url.host, url.port) do |http|
+          http.request(Net::HTTP::Get.new(url)) do |response|
+            return response.read_body
+          end
+        end
+      end
+
     end
   end
 end

data/lib/bel_parser/script/keywords.rb

@@ -4,8 +4,22 @@ module BELParser
       BEL_VERSION_STRING = 'BELVersion'.freeze
       BEL_VERSION_REGEX  = /\A#{BEL_VERSION_STRING}\Z/i
 
+      CITATION       = 'Citation'.freeze
+      CITATION_REGEX = /\A#{CITATION}\Z/i
+
+      SUPPORT       = 'Support'.freeze
+      SUPPORT_REGEX = /\A#{SUPPORT}\Z/i
+
       def is_bel_version?(string)
-        string.to_s.strip =~ BEL_VERSION_REGEX
+        string =~ BEL_VERSION_REGEX
+      end
+
+      def is_citation?(string)
+        string =~ CITATION_REGEX
+      end
+
+      def is_support?(string)
+        string =~ SUPPORT_REGEX
       end
     end
   end

data/lib/bel_parser/script/nanopub_mapper.rb

@@ -1,32 +1,93 @@
+require 'bel_parser/quoting'
+require_relative '../parsers/serializer'
+
 module BELParser
   module Script
-    # NanopubMapper maps BEL Script AST nodes to an aggregated nanopub.
+    # NanopubMapper maps BEL Script AST nodes and state to aggregated
+    # nanopub hash objects.
     class NanopubMapper
+      include BELParser::Parsers
+      include BELParser::Quoting
+
       STATEMENT_TYPES = [
         :simple_statement,
         :nested_statement,
         :observed_term
       ]
 
+      DEFINITIONS = [:annotation_definitions, :namespace_definitions]
+
       def initialize(ast_enum)
         @ast_enum = ast_enum
       end
 
-      def each
+      def each(&block)
         if block_given?
           @ast_enum.each do |(line_nunber, line, ast_node, state)|
             next unless STATEMENT_TYPES.include?(ast_node.type)
+            yield nanopub(ast_node, state, &block)
+          end
+        else
+          enum_for(:each)
+        end
+      end
+
+      def nanopub(ast_node, state, &block)
+        {
+          bel_statement:      serialize(ast_node),
+          citation:           citation(state[:citation]),
+          support:            support(state[:support]),
+          experiment_context: experiment_context(state[:annotations]),
+          references:         references(*state.values_at(*DEFINITIONS)),
+          metadata:           nil
+        }
+      end
+
+      def citation(citation)
+        citation.each do |field, value|
+          citation[field] = unquote(value)
+        end
+      end
 
-            # TODO Add StateFunction for capturing :citation.
-            # TODO Add BELSerializer AST processor. Serialize ast_node.
-            # TODO One time: Map annotation and namespace definitions.
+      def support(support)
+        unquote(support)
+      end
 
-            # TODO Collect annotations.
+      def experiment_context(annotations)
+        (annotations || []).map do |name, value|
+          {
+            name:  name,
+            value: value
+          }
+        end
+      end
 
-            # TODO Combine into hash. Yield.
+      def references(anno_defs, ns_defs)
+        {
+          annotations: (anno_defs || []).map do |keyword, (type, domain)|
+            {
+              keyword: keyword,
+              type:    type,
+              domain:  domain_value(type, domain)
+            }
+          end,
+          namespaces: (ns_defs || []).map do |keyword, uri|
+            {
+              keyword: keyword,
+              uri:     domain_value(:uri, uri)
+            }
           end
+        }
+      end
+
+      def domain_value(type, domain)
+        case type
+        when :uri
+          domain.identifier
+        when :list
+          domain
         else
-          enum_for(:each)
+          domain.to_s
         end
       end
     end
@@ -38,7 +99,9 @@ if __FILE__ == $PROGRAM_NAME
     File.join(File.expand_path(File.dirname(__FILE__)), '..', '..', '..', 'lib'))
 
   require 'json'
+  require 'bel_parser'
   require 'bel_parser/language'
+  require 'bel_parser/parsers/serializer'
   require 'bel_parser/script'
   require 'bel_parser/resource/resource_url_reader'
   include BELParser::Script
@@ -58,11 +121,18 @@ if __FILE__ == $PROGRAM_NAME
     namespace_definitions: namespaces
   }
 
-  NanopubMapper.new(
-    Validator.new(
-      StateAggregator.new(
-        FirstNode.new(Filter.new(BELParser::ASTGenerator.new(File.open(ARGV.first)))),
-        initial_state))).each do |nanopub|
-          JSON.dump(nanopub)
-        end
+  io =
+    if ARGV.first
+      File.open(ARGV.first)
+    else
+      $stdin
+    end
+
+  nanopubs =
+    NanopubMapper.new(
+      Validator.new(
+        StateAggregator.new(
+          FirstNode.new(Filter.new(BELParser::ASTGenerator.new(io))),
+          initial_state))).each.to_a
+  puts JSON.dump(nanopubs)
 end

data/lib/bel_parser/script/state/annotation_definition.rb

@@ -53,7 +53,7 @@ module BELParser
           url     = unquote(url_node.string.string_literal)
           dataset = script_context[:resource_reader].retrieve_resource(url)
           script_context[:annotation_definitions] ||= Concurrent::Hash.new
-          script_context[:annotation_definitions][prefix] = [:url, dataset]
+          script_context[:annotation_definitions][prefix] = [:uri, dataset]
         end
         private_class_method :handle_url
       end

data/lib/bel_parser/script/state/set.rb

@@ -2,6 +2,7 @@ require 'bel_parser/language'
 require 'bel_parser/quoting'
 require 'bel_parser/parsers/ast/node'
 require 'concurrent/hash'
+require_relative '../keywords'
 require_relative '../state_function'
 
 module BELParser
@@ -9,17 +10,24 @@ module BELParser
     module State
       class Set
         extend StateFunction
+        extend BELParser::Script::Keyword
         extend BELParser::Quoting
 
         TARGET_NODE = BELParser::Parsers::AST::Set
         LIST_NODE   = BELParser::Parsers::AST::List
+        FIELDS      = %w(type name id date authors comment)
 
         def self.consume(ast_node, script_context)
           return nil unless ast_node.is_a?(TARGET_NODE)
           name, value = ast_node.children
           name_string = name.identifier.string_literal
           value_node  = ast_node.value.children[0]
-          if value_node.is_a?(LIST_NODE)
+          case
+          when is_citation?(name_string)
+            handle_citation(value_node, script_context)
+          when is_support?(name_string)
+            handle_support(value_node, script_context)
+          when value_node.is_a?(LIST_NODE)
             value_node
               .list_items.map { |li| li.children[0].string_literal }
               .each do |string|
@@ -36,6 +44,22 @@ module BELParser
           end
         end
 
+        def self.handle_citation(value_node, script_context)
+          if value_node.is_a?(LIST_NODE)
+            script_context[:citation] =
+              Hash[
+                FIELDS.zip(
+                  value_node
+                    .list_items
+                    .map { |li| li.children[0].string_literal })
+              ]
+          end
+        end
+
+        def self.handle_support(value_node, script_context)
+          script_context[:support] = value_node.string_literal
+        end
+
         def self.handle_annotation(name, value, script_context)
           # add to annotation state
           script_context[:annotations]       ||= Concurrent::Hash.new
@@ -49,6 +73,7 @@ module BELParser
           # clear annotation state
           script_context[:annotations]     ||= Concurrent::Hash.new
           script_context[:annotations].clear
+          script_context[:citation] = nil
         end
         private_class_method :handle_statement_group
       end

data/lib/bel_parser/script/state/unset.rb

@@ -2,6 +2,7 @@ require 'bel_parser/language'
 require 'bel_parser/quoting'
 require 'bel_parser/parsers/ast/node'
 require 'concurrent/hash'
+require_relative '../keywords'
 require_relative '../state_function'
 
 module BELParser
@@ -9,6 +10,7 @@ module BELParser
     module State
       class Unset
         extend StateFunction
+        extend BELParser::Script::Keyword
         extend BELParser::Quoting
 
         TARGET_NODE = BELParser::Parsers::AST::Unset
@@ -27,14 +29,15 @@ module BELParser
         def self.handle_annotation(name, script_context)
           script_context[:annotations] ||= Concurrent::Hash.new
           script_context[:annotations].delete(name)
+          script_context[:citation] = nil if is_citation?(name)
         end
         private_class_method :handle_annotation
 
         def self.handle_statement_group(script_context)
           script_context.delete(:statement_group)
-
           script_context[:annotations] ||= Concurrent::Hash.new
           script_context[:annotations].clear
+          script_context[:citation] = nil
         end
         private_class_method :handle_statement_group
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bel_parser
 version: !ruby/object:Gem::Version
-  version: 1.0.0.alpha.20
+  version: 1.0.0.alpha.21
 platform: ruby
 authors:
 - Anthony Bargnesi
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-01 00:00:00.000000000 Z
+date: 2016-05-02 00:00:00.000000000 Z
 dependencies: []
 description: Implements language versions 1.0 and 2.0.
 email: abargnesi@selventa.com
@@ -27,7 +27,13 @@ files:
 - bin/bel2_validator
 - bin/bel_script_reader
 - lib/bel/translator/plugins/bel_script.rb
+- lib/bel/translator/plugins/bel_script/bel_citation_serialization.rb
+- lib/bel/translator/plugins/bel_script/bel_discrete_serialization.rb
+- lib/bel/translator/plugins/bel_script/bel_top_down_serialization.rb
+- lib/bel/translator/plugins/bel_script/evidence_serialization.rb
+- lib/bel/translator/plugins/bel_script/reader.rb
 - lib/bel/translator/plugins/bel_script/translator.rb
+- lib/bel/translator/plugins/bel_script/writer.rb
 - lib/bel_parser.rb
 - lib/bel_parser/ast_filter.rb
 - lib/bel_parser/ast_generator.rb