bel_parser 1.0.0.alpha.27-java

data/lib/bel_parser/script/keywords.rb

@@ -0,0 +1,32 @@
+module BELParser
+  module Script
+    module Keyword
+      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
+
+      IMPLICIT_ANNOTATIONS = ['Citation', 'Support', 'STATEMENT_GROUP']
+
+      def is_bel_version?(string)
+        string =~ BEL_VERSION_REGEX
+      end
+
+      def is_citation?(string)
+        string =~ CITATION_REGEX
+      end
+
+      def is_support?(string)
+        string =~ SUPPORT_REGEX
+      end
+
+      def is_implicit_annotation?(string)
+        IMPLICIT_ANNOTATIONS.any? { |annotation| string == annotation }
+      end
+    end
+  end
+end

data/lib/bel_parser/script/nanopub_mapper.rb

@@ -0,0 +1,182 @@
+require 'bel_parser/quoting'
+require_relative '../parsers/serializer'
+
+module BELParser
+  module Script
+    # 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, omit_on_error = false, omit_on_warning = false)
+        @ast_enum        = ast_enum
+        @omit_on_error   = omit_on_error
+        @omit_on_warning = omit_on_warning
+      end
+
+      def each
+        if block_given?
+          @ast_enum.each do |(num, line, ast_node, state)|
+            next unless STATEMENT_TYPES.include?(ast_node.type)
+
+            errors   = errors(ast_node)
+            warnings = warnings(ast_node)
+
+            if (@omit_on_error && !errors.empty?) ||
+              (@omit_on_warning && !warnings.empty?)
+
+              report(num, line, errors, warnings)
+              next
+            end
+
+            yield [num, line, ast_node, nanopub(ast_node, state)]
+          end
+        else
+          enum_for(:each)
+        end
+      end
+
+      def nanopub(ast_node, state)
+        {
+          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:           {
+            document_header: state[:document_properties] || nil
+          }
+        }
+      end
+
+      def report(num, line, errors, warnings)
+        warn "Line #{num}: #{line}"
+        errors.each do |err|
+          warn "  #{err}"
+        end
+        warnings.each do |warn|
+          warn "  #{warn}"
+        end
+        warn
+      end
+
+      def errors(ast_node)
+        ast_node
+          .syntax_errors
+          .select do |err|
+            err.is_a?(::BELParser::Language::Syntax::SyntaxError)
+          end.each(&:to_s)
+      end
+
+      def warnings(ast_node)
+        ast_node
+          .syntax_errors
+          .select do |warn|
+            warn.is_a?(::BELParser::Language::Syntax::SyntaxError) ||
+              warn.is_a?(::BELParser::Language::Semantics::SemanticsWarning)
+          end.each(&:to_s)
+      end
+
+      def citation(citation)
+        return nil unless citation
+        citation.each do |field, value|
+          citation[field] = unquote(value)
+        end
+      end
+
+      def support(support)
+        unquote(support)
+      end
+
+      def experiment_context(annotations)
+        (annotations || []).map do |name, value|
+          {
+            name:  name,
+            value: unquote(value)
+          }
+        end
+      end
+
+      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
+          domain.to_s
+        end
+      end
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  $LOAD_PATH.unshift(
+    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
+
+  rr = BELParser::Resource::ResourceURLReader.new(true)
+  namespaces = Hash[
+    ARGV.map do |ns|
+      prefix, identifier = ns.split('=')
+      dataset            = rr.retrieve_resource(identifier)
+      dataset ? [prefix, dataset] : nil
+    end.compact
+  ]
+
+  initial_state = {
+    resource_reader:       rr,
+    specification:         BELParser::Language.specification('2.0'),
+    namespace_definitions: namespaces
+  }
+
+  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.map(&:last).to_a
+  puts JSON.dump(nanopubs)
+end

data/lib/bel_parser/script/parser.rb

@@ -0,0 +1,51 @@
+require_relative '../ast_filter'
+require_relative '../ast_generator'
+require_relative '../parsers/common'
+require_relative '../parsers/expression'
+require_relative '../parsers/bel_script'
+
+module BELParser
+  module Script
+    # Parser for BEL Script.
+    class Parser
+      include BELParser::Parsers::Common
+      include BELParser::Parsers::Expression
+      include BELParser::Parsers::BELScript
+
+      TYPES = [
+        :simple_statement,
+        :observed_term,
+        :nested_statement,
+        :annotation_definition,
+        :namespace_definition,
+        :set,
+        :document_property,
+        :unset,
+        :blank_line,
+        :comment_line
+      ]
+
+      def each(io)
+        if block_given?
+          filter = BELParser::ASTFilter.new(
+            BELParser::ASTGenerator.new(io),
+            *TYPES)
+          filter.each do |results|
+            yield results
+          end
+        else
+          enum_for(:each, io)
+        end
+      end
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  BELParser::Script::Parser.new.each($stdin) do |(line_number, line, results)|
+    puts "#{line_number}: #{line}"
+    results.each do |ast|
+      puts ast.to_s(1)
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+require 'bel_parser/language'
+require 'bel_parser/quoting'
+require 'bel_parser/parsers/ast/node'
+require 'concurrent/hash'
+require_relative '../state_function'
+
+module BELParser
+  module Script
+    module State
+      class AnnotationDefinition
+        extend StateFunction
+        extend BELParser::Quoting
+
+        TARGET_NODE = BELParser::Parsers::AST::AnnotationDefinition
+
+        def self.consume(ast_node, script_context)
+          return nil unless ast_node.is_a?(TARGET_NODE)
+          resource_reader = script_context[:resource_reader]
+
+          keyword, domain = ast_node.children
+          prefix          = keyword.identifier.string_literal
+          case
+          when domain.list?
+            handle_list(prefix, domain.child, script_context)
+          when domain.url?
+            handle_url(prefix, domain.child, script_context)
+          when domain.pattern?
+            handle_pattern(prefix, domain.child, script_context)
+          end
+        end
+
+        def self.handle_list(prefix, list_node, script_context)
+          script_context[:annotation_definitions] ||= Concurrent::Hash.new
+          script_context[:annotation_definitions][prefix] = [
+            :list,
+            list_node.list_items.map do |li|
+              unquote(li.children[0].string_literal)
+            end
+          ]
+        end
+        private_class_method :handle_list
+
+        def self.handle_pattern(prefix, pattern_node, script_context)
+          script_context[:annotation_definitions] ||= Concurrent::Hash.new
+          script_context[:annotation_definitions][prefix] = [
+            :pattern,
+            unquote(pattern_node.string)
+          ]
+        end
+        private_class_method :handle_pattern
+
+        def self.handle_url(prefix, url_node, script_context)
+          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] = [:uri, dataset]
+        end
+        private_class_method :handle_url
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'bel_parser/language'
+require 'bel_parser/parsers/ast/node'
+require 'bel_parser/quoting'
+require 'concurrent/hash'
+require_relative '../keywords'
+require_relative '../state_function'
+
+module BELParser
+  module Script
+    module State
+      class BELVersion
+        extend StateFunction
+        extend BELParser::Quoting
+        extend Keyword
+
+        TARGET_NODE         = BELParser::Parsers::AST::DocumentProperty
+        DEFAULT_BEL_VERSION = '2.0'
+
+        def self.consume(ast_node, script_context)
+          return unless ast_node.is_a?(TARGET_NODE)
+          name, value = ast_node.children
+          name_string  = name.identifier.string_literal
+          return unless is_bel_version?(name_string)
+
+          value_string = unquote(value.children[0].string_literal)
+          begin
+            spec = BELParser::Language.specification(value_string)
+          rescue ArgumentError
+            spec = BELParser::Language.specification(DEFAULT_BEL_VERSION)
+          end
+          script_context[:specification] = spec
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'bel_parser/parsers/ast/node'
+require 'bel_parser/quoting'
+require 'concurrent/hash'
+require_relative '../state_function'
+
+module BELParser
+  module Script
+    module State
+      class DocumentProperty
+        extend StateFunction
+        extend BELParser::Quoting
+
+        TARGET_NODE = BELParser::Parsers::AST::DocumentProperty
+
+        def self.consume(ast_node, script_context)
+          return nil unless ast_node.is_a?(TARGET_NODE)
+          hash = script_context[:document_properties] ||= Concurrent::Hash.new
+
+          name, value = ast_node.children
+          if name && value
+            name_string  = name.identifier.string_literal
+            value_string = value.children[0].string_literal
+            hash[name_string] = unquote(value_string)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'bel_parser/language'
+require 'bel_parser/quoting'
+require 'bel_parser/parsers/ast/node'
+require 'concurrent/hash'
+require_relative '../state_function'
+
+module BELParser
+  module Script
+    module State
+      class NamespaceDefinition
+        extend StateFunction
+        extend BELParser::Quoting
+
+        TARGET_NODE = BELParser::Parsers::AST::NamespaceDefinition
+
+        def self.consume(ast_node, script_context)
+          return nil unless ast_node.is_a?(TARGET_NODE)
+          resource_reader = script_context[:resource_reader]
+
+          keyword, domain = ast_node.children
+          if domain.url?
+            prefix  = keyword.identifier.string_literal
+            url     = unquote(domain.child.string.string_literal)
+            dataset = resource_reader.retrieve_resource(url)
+            script_context[:namespace_definitions] ||= Concurrent::Hash.new
+            script_context[:namespace_definitions][prefix] = dataset
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+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
+  module Script
+    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]
+          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|
+                handle_annotation(name_string, string, script_context)
+              end
+          else
+            value_string = value_node.string_literal
+            case name_string
+            when /\ASTATEMENT_GROUP\Z/
+              handle_statement_group(value_string, script_context)
+            else
+              handle_annotation(name_string, value_string, script_context)
+            end
+          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
+          script_context[:annotations][name]   = value
+        end
+        private_class_method :handle_annotation
+
+        def self.handle_statement_group(value, script_context)
+          script_context[:statement_group] = value
+
+          # 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
+    end
+  end
+end