bel_parser 1.0.0.alpha.27-java

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

@@ -0,0 +1,46 @@
+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 Unset
+        extend StateFunction
+        extend BELParser::Script::Keyword
+        extend BELParser::Quoting
+
+        TARGET_NODE = BELParser::Parsers::AST::Unset
+
+        def self.consume(ast_node, script_context)
+          return nil unless ast_node.is_a?(TARGET_NODE)
+          name_string = ast_node.name.identifier.string_literal
+          case name_string
+          when /\ASTATEMENT_GROUP\Z/
+            handle_statement_group(script_context)
+          else
+            handle_annotation(name_string, script_context)
+          end
+        end
+
+        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
+    end
+  end
+end

data/lib/bel_parser/script/state_aggregator.rb

@@ -0,0 +1,49 @@
+module BELParser
+  module Script
+    # StateAggregator aggregates BEL Script state for each
+    # {BELParser::Parsers::AST::Node AST node} it processes.
+    class StateAggregator
+
+      STATE_PATH = 'state'
+
+      def initialize(ast_enum, options = {})
+        @ast_enum        = ast_enum
+        @script_context  = {}.merge(options)
+
+        StateAggregator.require_script_path
+        @state_functions = StateAggregator.state_constants(State)
+      end
+
+      def each
+        if block_given?
+          @ast_enum.each do |(line_number, line, ast_node)|
+            ast_node.traverse.each do |node|
+              @state_functions.each do |func|
+                func.consume(node, @script_context)
+              end
+            end
+            yield [line_number, line, ast_node, @script_context]
+          end
+        else
+          enum_for(:each)
+        end
+      end
+
+      def self.require_script_path
+        base_path = File.expand_path(File.dirname(__FILE__)) + File::SEPARATOR
+        Dir[File.join(base_path, STATE_PATH, '*.rb')]
+          .each do |ruby_file|
+            ruby_file.sub!(/^#{Regexp.escape(base_path)}/, '')
+            require_relative ruby_file
+          end
+      end
+
+      def self.state_constants(mod)
+        mod.constants.collect do |symbol|
+          const = mod.const_get(symbol)
+          const if const.respond_to?(:consume)
+        end.compact
+      end
+    end
+  end
+end

data/lib/bel_parser/script/state_function.rb

@@ -0,0 +1,10 @@
+module BELParser
+  module Script
+    module StateFunction
+      # @abstract Extend {StateFunction} and override {#consume}.
+      def consume(ast_node, script_context)
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+    end
+  end
+end

data/lib/bel_parser/script/syntax/expression_validation.rb

@@ -0,0 +1,46 @@
+require 'bel_parser/language'
+require 'bel_parser/language/expression_validator'
+require 'bel_parser/language/syntax_function'
+require 'bel_parser/language/syntax_warning'
+require 'bel_parser/quoting'
+require 'bel_parser/parsers/ast/node'
+require 'concurrent/hash'
+
+module BELParser
+  module Script
+    module Syntax
+      class ExpressionValidation
+        extend BELParser::Language::Syntax::SyntaxFunction
+        extend BELParser::Quoting
+
+        TARGET_NODES = [
+          BELParser::Parsers::AST::ObservedTerm,
+          BELParser::Parsers::AST::SimpleStatement,
+          BELParser::Parsers::AST::NestedStatement
+        ]
+        EXP_VALIDATOR = BELParser::Language::ExpressionValidator
+
+        def self.map(ast_node, script_context)
+          return nil unless TARGET_NODES.include?(ast_node.class)
+          return nil unless script_context.key?(:specification)
+
+          validator = expression_validator(script_context)
+          validator.validate(ast_node).select(&:failure?)
+        end
+
+        def self.expression_validator(script_context)
+          unless defined? @expression_validator
+            spec, namespaces, reader =
+              script_context
+              .values_at(
+                :specification,
+                :namespace_definitions,
+                :resource_reader)
+            @expression_validator = EXP_VALIDATOR.new(spec, namespaces, reader)
+          end
+          @expression_validator
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/script/syntax/invalid_regex_pattern.rb

@@ -0,0 +1,49 @@
+require 'bel_parser/language'
+require 'bel_parser/language/syntax_function'
+require 'bel_parser/language/syntax_error'
+require 'bel_parser/quoting'
+require 'bel_parser/parsers/ast/node'
+require 'concurrent/hash'
+
+module BELParser
+  module Script
+    module Syntax
+      class InvalidRegexPattern
+        extend BELParser::Language::Syntax::SyntaxFunction
+        extend BELParser::Quoting
+
+        TARGET_NODE = BELParser::Parsers::AST::Pattern
+
+        def self.map(ast_node, script_context)
+          return nil unless ast_node.is_a?(TARGET_NODE)
+          pattern = unquote(ast_node.string.string_literal)
+          begin
+            Regexp.new(pattern)
+            nil
+          rescue RegexpError => error
+            InvalidRegexPatternError.new(ast_node, pattern, error.to_s)
+          end
+        end
+      end
+
+      # InvalidRegexPattern indicates that a pattern represented an invalid
+      # regular expression.
+      class InvalidRegexPatternError < BELParser::Language::Syntax::SyntaxError
+        # Gets the invalid pattern.
+        attr_reader :pattern
+
+        def initialize(pattern_node, pattern, error_msg)
+          super(pattern_node, nil)
+          @pattern   = pattern
+          @error_msg = error_msg
+        end
+
+        def msg
+          <<-MSG.gsub(/^ +/, '').delete("\n")
+            "#@pattern" is not a valid regular expression (#@error_msg).
+          MSG
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/script/syntax/undefined_annotation.rb

@@ -0,0 +1,61 @@
+require 'bel_parser/language'
+require 'bel_parser/language/syntax_function'
+require 'bel_parser/language/syntax_error'
+require 'bel_parser/quoting'
+require 'bel_parser/parsers/ast/node'
+require 'concurrent/hash'
+require_relative '../keywords'
+
+module BELParser
+  module Script
+    module Syntax
+      class UndefinedAnnotation
+        extend BELParser::Language::Syntax::SyntaxFunction
+        extend BELParser::Script::Keyword
+
+        TARGET_NODE       = BELParser::Parsers::AST::Set
+
+        def self.map(ast_node, script_context)
+          return nil unless ast_node.is_a?(TARGET_NODE)
+          name_string = ast_node.name.identifier.string_literal
+          annotation_definitions =
+            script_context[:annotation_definitions] ||= Concurrent::Hash.new
+
+          return nil if is_implicit_annotation?(name_string)
+          return nil if annotation_definitions.key?(name_string)
+          UndefinedAnnotationError.new(
+            ast_node,
+            name_string,
+            script_context[:annotation_definitions])
+        end
+      end
+
+      # UndefinedAnnotationError represents an undefined annotation seen when
+      # checking a SET annotation.
+      class UndefinedAnnotationError < BELParser::Language::Syntax::SyntaxError
+        # Gets the undefined prefix.
+        attr_reader :prefix
+
+        def initialize(set_node, prefix, annotation_definitions)
+          super(set_node, nil)
+          @prefix                 = prefix
+          @annotation_definitions = annotation_definitions
+        end
+
+        def msg
+          defined_annotations =
+            if @annotation_definitions.empty?
+              'No annotations are defined.'
+            else
+              annotation_prefixes = @annotation_definitions.keys.join(', ')
+              "Defined annotations: #{annotation_prefixes}"
+            end
+          <<-MSG.gsub(/^ +/, '').delete("\n")
+            Annotation definition is missing for "#@prefix". 
+            #{defined_annotations}
+          MSG
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/script/syntax/undefined_annotation_value.rb

@@ -0,0 +1,84 @@
+require 'bel_parser/language'
+require 'bel_parser/language/syntax_function'
+require 'bel_parser/language/syntax_warning'
+require 'bel_parser/quoting'
+require 'bel_parser/parsers/ast/node'
+require 'concurrent/hash'
+require_relative '../keywords'
+
+module BELParser
+  module Script
+    module Syntax
+      class UndefinedAnnotationValue
+        extend BELParser::Language::Syntax::SyntaxFunction
+        extend BELParser::Quoting
+        extend BELParser::Script::Keyword
+
+        TARGET_NODE       = BELParser::Parsers::AST::Set
+        LIST_NODE         = BELParser::Parsers::AST::List
+
+        def self.map(ast_node, script_context)
+          return nil unless ast_node.is_a?(TARGET_NODE)
+          name, value  = ast_node.children
+          name_string  = ast_node.name.identifier.string_literal
+
+          return nil if is_implicit_annotation?(name_string)
+          dataset = annotation(name_string, script_context)
+          return nil unless dataset
+
+          rr         = script_context[:resource_reader]
+          value_node = ast_node.value.children[0]
+          if value_node.is_a?(LIST_NODE)
+            value_node
+              .list_items.map { |li| li.children[0].string_literal }
+              .map do |string|
+                map_value(ast_node, name_string, string, dataset.identifier, rr)
+              end
+          else
+            map_value(
+              ast_node,
+              name_string,
+              value_node.string_literal,
+              dataset.identifier,
+              rr)
+          end
+        end
+
+        def self.annotation(name_string, script_context)
+          hash =
+            script_context[:annotation_definitions] ||= Concurrent::Hash.new
+          type, definition = hash[name_string]
+          type == :url ? definition : nil
+        end
+
+        def self.map_value(ast_node, name_string, value_string, identifier, rr)
+          value_string = unquote(value_string)
+          value = rr.retrieve_value_from_resource(identifier, value_string)
+          UndefinedAnnotationValueWarning.new(
+            ast_node,
+            name_string,
+            value_string) unless value
+        end
+      end
+
+      # UndefinedAnnotationValueWarning represents an undefined annotation value
+      # while checking a SET annotation.
+      class UndefinedAnnotationValueWarning < BELParser::Language::Syntax::SyntaxWarning
+        # Gets the prefix.
+        attr_reader :prefix
+        # Gets the undefined annotation value.
+        attr_reader :value
+
+        def initialize(set_node, prefix, value)
+          super(set_node, nil)
+          @prefix = prefix
+          @value  = value
+        end
+
+        def msg
+          %(Undefined annotation value "#@value" for annotation "#@prefix".)
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/script/syntax/unresolvable_namespace.rb

@@ -0,0 +1,54 @@
+require 'bel_parser/language'
+require 'bel_parser/language/syntax_function'
+require 'bel_parser/language/syntax_error'
+require 'bel_parser/quoting'
+require 'bel_parser/parsers/ast/node'
+require 'concurrent/hash'
+
+module BELParser
+  module Script
+    module Syntax
+      class UnresolvableNamespace
+        extend BELParser::Language::Syntax::SyntaxFunction
+        extend BELParser::Quoting
+
+        TARGET_NODE = BELParser::Parsers::AST::NamespaceDefinition
+
+        def self.map(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?
+            url = unquote(domain.child.string.string_literal)
+            unless resource_reader.retrieve_resource(url)
+              prefix = keyword.identifier.string_literal
+              return UnresolvableNamespaceError.new(ast_node, prefix, url)
+            end
+          end
+
+          nil
+        end
+      end
+
+      # UnresolvableNamespaceError indicates that a namespace resource could
+      # not be resolved.
+      class UnresolvableNamespaceError < BELParser::Language::Syntax::SyntaxError
+        # Gets the unresolvable namespace prefix.
+        attr_reader :prefix
+        # Gets the unresolvable namespace identifier.
+        attr_reader :identifier
+
+        def initialize(define_namespace_node, prefix, identifier)
+          super(define_namespace_node, nil)
+          @prefix     = prefix
+          @identifier = identifier
+        end
+
+        def msg
+          %(Could not resolve "#@prefix" with identifier "#@identifier".)
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/script/syntax/unsupported_bel_version.rb

@@ -0,0 +1,59 @@
+require 'bel_parser/language'
+require 'bel_parser/language/syntax_function'
+require 'bel_parser/language/syntax_error'
+require 'bel_parser/quoting'
+require 'bel_parser/parsers/ast/node'
+require 'concurrent/hash'
+require_relative '../keywords'
+
+module BELParser
+  module Script
+    module Syntax
+      class UnsupportedBELVersion
+        extend BELParser::Language::Syntax::SyntaxFunction
+        extend BELParser::Quoting
+        extend Keyword
+
+        TARGET_NODE         = BELParser::Parsers::AST::DocumentProperty
+
+        def self.map(ast_node, script_context)
+          return nil unless ast_node.is_a?(TARGET_NODE)
+          name, value = ast_node.children
+          name_string  = name.identifier.string_literal
+          return nil unless is_bel_version?(name_string)
+
+          value_string = unquote(value.children[0].string_literal)
+          begin
+            BELParser::Language.specification(value_string)
+            nil
+          rescue ArgumentError
+            latest_version = BELParser::Language.latest_supported_version
+            latest_spec    = BELParser::Language.specification(latest_version)
+            script_context[:specification] = latest_spec
+            UnsupportedBELVersionWarning.new(ast_node, value_string)
+          end
+        end
+      end
+
+      # UnsupportedBELVersionError represents the use of an unsupported
+      # BEL version string.
+      class UnsupportedBELVersionWarning < BELParser::Language::Syntax::SyntaxWarning
+        # Gets the unsupported bel version.
+        attr_reader :unsupported_version
+
+        def initialize(document_property_node, unsupported_version)
+          super(document_property_node, nil)
+          @unsupported_version = unsupported_version
+          @latest              = BELParser::Language.latest_supported_version
+        end
+
+        def msg
+          <<-MSG.gsub(/^ +/, '').delete("\n")
+            Unsupported BEL version "#@unsupported_version". 
+            Setting BEL version to the latest supported version "#@latest".
+          MSG
+        end
+      end
+    end
+  end
+end