bel_parser 1.0.0.alpha.27-java

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

@@ -0,0 +1,39 @@
+require 'bel_parser'
+require 'bel_parser/resource/resource_url_reader'
+require 'bel/nanopub'
+
+module BEL::Translator::Plugins
+  module BelScript
+    class Reader
+      include ::BELParser::Script
+      
+      SyntaxError = ::BELParser::Language::Syntax::SyntaxError
+
+      def initialize(io, options = {})
+        @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)),
+            true,
+            false
+          ).each do |(num, line, ast_node, nanopub_hash)|
+            yield ::BEL::Nanopub::Nanopub.create(nanopub_hash)
+          end
+        else
+          enum_for(:each)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# 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
+    # BelScriptTranslator defines a {BEL::Translator} that can read/write
+    # BEL Script using the Nanopub model.
+    class BelScriptTranslator
+      include ::BEL::Translator
+
+      def read(data, options = {})
+        Reader.new(data)
+      end
+
+      def write(objects, writer = StringIO.new, options = {})
+        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
+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::Nanopub::Nanopub} to
+      # BEL Script.
+      #
+      # @param [Enumerator<BEL::Nanopub::Nanopub>] data nanopubs 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 nanopub; 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::Nanopub::StreamingNanopubCombiner.new(@data)
+            elsif @annotation_reference_map && @namespace_reference_map
+              BEL::Nanopub::MapReferencesCombiner.new(
+                @data,
+                BEL::Nanopub::HashMapReferences.new(
+                  @annotation_reference_map,
+                  @namespace_reference_map
+                )
+              )
+            else
+              BEL::Nanopub::BufferingNanopubCombiner.new(@data)
+            end
+
+          header_flag = true
+          combiner.each { |nanopub|
+
+            # serialize nanopub
+            bel = to_bel(nanopub)
+
+            if @write_header && header_flag
+              yield document_header(nanopub.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.rb

@@ -0,0 +1,23 @@
+# vendored 'ast' gem
+require 'bel_parser/vendor/ast'
+
+# AST model
+require 'bel_parser/parsers/ast/node'
+
+# ragel parsers
+require 'bel_parser/parsers/common'
+require 'bel_parser/parsers/expression'
+require 'bel_parser/parsers/bel_script'
+
+# AST processors
+require 'bel_parser/ast_generator'
+require 'bel_parser/ast_filter'
+
+# Language; version-independent classes
+require 'bel_parser/language'
+
+# BEL expression support
+require 'bel_parser/expression'
+
+# BEL Script support
+require 'bel_parser/script'

data/lib/bel_parser/ast_filter.rb

@@ -0,0 +1,44 @@
+require_relative 'parsers/ast/node'
+
+module BELParser
+  # ASTFilter filters types of {BELParser::Parsers::AST::Node}.
+  class ASTFilter
+    def initialize(ast_enum, *types)
+      @ast_enum = ast_enum
+      @types    = types
+    end
+
+    def each
+      if block_given?
+        @ast_enum.each do |(line_number, line, ast_results)|
+          selected = filter(ast_results)
+          yield([line_number, line, selected]) unless selected.empty?
+        end
+      else
+        enum_for(:each)
+      end
+    end
+
+    def filter(ast_enum)
+      ast_enum.select do |node|
+        @types.include?(node.type)
+      end
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  require_relative 'ast_generator'
+
+  types     = ARGV.map(&:to_sym)
+  generator = BELParser::ASTGenerator.new($stdin)
+  BELParser::ASTFilter.new(
+    generator,
+    *types
+  ).each do |(line_number, line, results)|
+    puts "#{line_number}: #{line}"
+    results.each do |result_ast|
+      puts result_ast.to_s(1)
+    end
+  end
+end

data/lib/bel_parser/ast_generator.rb

@@ -0,0 +1,83 @@
+require_relative 'parsers/common'
+require_relative 'parsers/expression'
+require_relative 'parsers/bel_script'
+require_relative 'mixin/line_mapping'
+require_relative 'mixin/line_continuator'
+
+module BELParser
+  # ASTGenerator yields AST results for each line in some {IO}.
+  # See #{ASTGenerator#each}.
+  class ASTGenerator
+    include LineMapping
+    include LineContinuator
+
+    map_const = ->(x) { x.constants.map { |c| x.const_get(c) } }
+    PARSERS = [
+      map_const.call(BELParser::Parsers::Common),
+      map_const.call(BELParser::Parsers::Expression),
+      map_const.call(BELParser::Parsers::BELScript)
+    ].flatten!
+
+    def initialize(io)
+      @io = io
+    end
+
+    # Yields AST results for each line of the IO.
+    #
+    # @example Receive AST results in given block.
+    #   # doctest setup require 'bel_parser' self.class.include AST::Sexp
+    #
+    #   # example usage line_io = StringIO.new("\"AKT1\"\n") line    =
+    #   nil ast_res = nil ::BELParser::ASTGenerator.new.each(line_io)
+    #   { |(line_number, line, results)|
+    #     # do something
+    #   }
+    #
+    # @example Receive AST results as an enumerator.
+    #   # doctest setup require 'bel_parser' self.class.include AST::Sexp
+    #
+    #   # example usage line_io = StringIO.new("\"AKT1\"\n") line,
+    #   ast_res = ::BELParser::ASTGenerator.new.each(line_io).first.to_a
+    #
+    # @param  [IO] io the IO-object to read each line from @yield
+    # [[Integer, String, Array<AST::Node>]] yields line number, line,
+    #         and AST results as an {Array}
+    # @return [IO, #<Enumerator: #<BELParser::ASTGenerator#each>] the {IO}
+    #         object is returned if a block is given, otherwise an
+    #         {Enumerator} object is returned that can be iterated with
+    #         {Enumerator#each}
+    def each # rubocop:disable MethodLength
+      if block_given?
+        line_enumerator = map_lines(@io.each_line.lazy)
+
+        line_number = 1
+        loop do
+          begin
+            line = expand_line_continuator(line_enumerator)
+
+            ast_results = []
+            PARSERS.map do |parser|
+              parser.parse(line) { |ast| ast_results << ast }
+            end
+            yield [line_number, line, ast_results]
+            line_number += 1
+          rescue StopIteration
+            return
+          end
+        end
+      else
+        enum_for(:each)
+      end
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  BELParser::ASTGenerator.new($stdin).each do |line_results|
+    line_number, line, ast_results = line_results
+    puts "#{line_number}: #{line}"
+    ast_results.each do |ast|
+      puts ast.to_s(1)
+    end
+  end
+end

data/lib/bel_parser/expression.rb

@@ -0,0 +1,3 @@
+require_relative 'expression/filter'
+require_relative 'expression/parser'
+require_relative 'expression/validator'

data/lib/bel_parser/expression/filter.rb

@@ -0,0 +1,31 @@
+require_relative '../ast_filter'
+
+module BELParser
+  module Expression
+    # Filter will enumerate {BELParser::Parsers::AST::Node AST nodes} that make
+    # up BEL expressions. It selects the relevant nodes
+    # from an {BELParser::Parsers::AST::Node AST node} enumerator.
+    class Filter
+      # Represents BEL expression node types.
+      TYPES = [
+        :simple_statement,
+        :observed_term,
+        :nested_statement,
+        :term,
+        :parameter
+      ]
+
+      def initialize(ast_enum)
+        @ast_filter = BELParser::ASTFilter.new(ast_enum, *TYPES)
+      end
+
+      def each(&block)
+        if block_given?
+          @ast_filter.each(&block)
+        else
+          enum_for(:each)
+        end
+      end
+    end
+  end
+end