bel_parser 1.0.0.alpha.27-java

data/lib/bel_parser/language/semantics_ast_warnings.rb

@@ -0,0 +1,180 @@
+require 'bel_parser/parsers/ast/node'
+require_relative 'semantics_warning'
+
+module BELParser
+  module Language
+    module Semantics
+      class SemanticsNilNodeWarning < SemanticsWarning
+        attr_reader :expected_type
+
+        def initialize(expression_node, spec, expected)
+          super(expression_node, spec)
+          @expected_type = expected.ast_type
+        end
+
+        def to_s
+          %(Missing the #{@expected_type} type.)
+        end
+      end
+
+      class SemanticsNotNilNodeWarning < SemanticsWarning
+        attr_reader :actual_type
+
+        def initialize(expression_node, spec)
+          super(expression_node, spec)
+          @actual_type = expression_node.type
+        end
+
+        def to_s
+          %(Expected nothing, but saw #{actual_type} type.)
+        end
+      end
+
+      class SemanticsTypeWarning < SemanticsWarning
+        attr_reader :expected_type, :actual_type
+
+        def initialize(expression_node, spec, expected, actual)
+          super(expression_node, spec)
+          @expected_type = expected.ast_type
+          @actual_type   = actual.type
+        end
+
+        def to_s
+          %(Expected #{expected_type} type, but saw #{actual_type} type.)
+        end
+      end
+
+      class SemanticsArgumentLengthWarning < SemanticsWarning
+        attr_reader :expected_type, :actual_type
+
+        def initialize(expression_node, spec, expected, actual)
+          super(expression_node, spec)
+          @expected_length = expected.arguments.length
+          @actual_length   = actual.arguments.length
+        end
+
+        def to_s
+          %(Expected #@expected_length arguments, but saw #@actual_length arguments.)
+        end
+      end
+
+      class SemanticsMissingNamespaceWarning < SemanticsWarning
+        def initialize(expression_node, spec)
+          super(expression_node, spec)
+        end
+
+        def to_s
+          prefix = @expression_node.identifier.string_literal
+          %(Missing namespace for prefix "#{prefix}".)
+        end
+      end
+
+      class SemanticsInvalidNamespaceWarning < SemanticsWarning
+        def initialize(expression_node, spec, expected_namespaces)
+          super(expression_node, spec)
+          @expected_namespaces = expected_namespaces
+        end
+
+        def to_s
+          namespace =
+            @expression_node.namespace &&
+            @expression_node.namespace.identifier
+          %(Invalid namespace "#{namespace}". Was expecting one of: #{@expected_namespaces.join(', ')})
+        end
+      end
+
+      class SemanticsMissingEncodingWarning < SemanticsWarning
+        def initialize(expression_node, spec)
+          super(expression_node, spec)
+        end
+
+        def to_s
+          value = @expression_node.children[0].string_literal
+          %(Missing encoding for value "#{value}".)
+        end
+      end
+
+      class SemanticsInvalidEncodingWarning < SemanticsWarning
+        def initialize(expression_node, spec, expected_encodings)
+          super(expression_node, spec)
+          @expected_encodings = expected_encodings
+        end
+
+        def to_s
+          encoding = @expression_node.encoding
+          %(Encoding of "#{encoding}" does not match expected: #{@expected_encodings.join(', ')})
+        end
+      end
+
+      class SemanticsInvalidFunctionWarning < SemanticsWarning
+        def initialize(expression_node, spec, expected_functions)
+          super(expression_node, spec)
+          @expected_functions = expected_functions
+        end
+
+        def to_s
+          function = @expression_node.string_literal
+          %(Function of "#{function}" does not match expected: #{@expected_functions.join(', ')})
+        end
+      end
+
+      class SemanticsInvalidReturnTypeWarning < SemanticsWarning
+        def initialize(expression_node, spec, expected_return_types)
+          super(expression_node, spec)
+          @expected_return_types = expected_return_types
+        end
+
+        def to_s
+          function = @expression_node.string_literal
+          %(Function of "#{function}" does not match return types: #{@expected_return_types.join(', ')})
+        end
+      end
+
+      class SemanticsInvalidProteinModificationWarning < SemanticsWarning
+        def initialize(expression_node, spec, expected_protein_modifications)
+          super(expression_node, spec)
+          @expected_protein_modifications = expected_protein_modifications
+        end
+
+        def to_s
+          pmod = @expression_node.children[0].string_literal
+          %(Protein modification of "#{pmod}" does not match allowed protein modifications: #{@expected_protein_modifications.join(', ')})
+        end
+      end
+
+      class SemanticsInvalidAminoAcidWarning < SemanticsWarning
+        def initialize(expression_node, spec, expected_amino_acids)
+          super(expression_node, spec)
+          @expected_amino_acids = expected_amino_acids
+        end
+
+        def to_s
+          amino_acid = @expression_node.children[0].string_literal
+          %(Amino acid of "#{amino_acid}" does not match allowed amino acids: #{@expected_amino_acids.join(', ')})
+        end
+      end
+
+      class SemanticsInvalidAminoAcidRangeWarning < SemanticsWarning
+        def initialize(expression_node, spec)
+          super(expression_node, spec)
+        end
+
+        def to_s
+          amino_acid_range = @expression_node.children[0].string_literal
+          %(Invalid amino acid range "#{amino_acid_range}".)
+        end
+      end
+
+      class SemanticsInvalidSequencePositionWarning < SemanticsWarning
+        def initialize(expression_node, spec)
+          super(expression_node, spec)
+        end
+
+        def to_s
+          pos = @expression_node.children[0].string_literal
+          %(Sequence position of "#{pos}" is not a positive number.)
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/language/semantics_function.rb

@@ -0,0 +1,16 @@
+module BELParser
+  module Language
+    module Semantics
+      # SemanticsFunction provides a {#map} function that maps a
+      # {BELParser::Parsers::AST::Node} to one or more
+      # {SemanticsResult semantics results}.
+      module SemanticsFunction
+        # @abstract Include {SemanticsFunction} and override {#map} to check
+        # term semantics (e.g. signatures).
+        def self.map(_term_ast, _spec, _namespaces)
+          raise NotImplementedError, "#{__method__} is not implemented."
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/language/semantics_match.rb

@@ -0,0 +1,28 @@
+module BELParser
+  module Language
+    module Semantics
+      # SemanticMatch holds the results of an input AST to semantic AST match.
+      class SemanticMatch
+        attr_reader :input_node, :semantic_node
+
+        def initialize(success, input_node, semantic_node)
+          @success       = success
+          @input_node    = input_node
+          @semantic_node = semantic_node
+        end
+
+        def success?
+          @success
+        end
+
+        def failure?
+          !@success
+        end
+
+        def to_s
+          msg
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/language/semantics_result.rb

@@ -0,0 +1,33 @@
+module BELParser
+  module Language
+    module Semantics
+      # SemanticsResult represents the successful outcome of applying a
+      # {SemanticsFunction}.
+      class SemanticsResult
+        attr_reader :expression_node, :specification
+
+        def initialize(expression_node, specification)
+          @expression_node = expression_node
+          @specification   = specification
+        end
+
+        def success?
+          true
+        end
+
+        def failure?
+          false
+        end
+
+        # @abstract Subclass and override {#msg} to provide the message.
+        def msg
+          "Successful semantic validation of #{@expression_node.type}."
+        end
+
+        def to_s
+          "Info: #{msg}"
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/language/semantics_type_warning.rb

@@ -0,0 +1,22 @@
+require 'bel_parser/parsers/ast/node'
+require_relative 'semantics_warning'
+
+module BELParser
+  module Language
+    module Semantics
+      class SemanticsTypeWarning < SemanticsWarning
+        attr_reader :expected_type, :actual_type
+
+        def initialize(expression_node, expected_type, actual_type, spec)
+          super(expression_node, spec)
+          @expected_type = expected_type
+          @actual_type   = actual_type
+        end
+
+        def to_s
+          %(Expected #{expected_type} type, but saw #{actual_type} type.)
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/language/semantics_warning.rb

@@ -0,0 +1,27 @@
+require_relative 'semantics_result'
+
+module BELParser
+  module Language
+    module Semantics
+      # SemanticsWarning defines a {SemanticsResult} that should be regarded as
+      # a warning with the expression.
+      class SemanticsWarning < SemanticsResult
+        def initialize(expression_node, specification)
+          super(expression_node, specification)
+        end
+
+        def success?
+          false
+        end
+
+        def failure?
+          true
+        end
+
+        def to_s
+          "Warning: #{msg}"
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/language/signature.rb

@@ -0,0 +1,39 @@
+module BELParser
+  module Language
+    # Signature defines the interface for language-specific signatures used
+    # to check expression semantics.
+    module Signature
+      include Comparable
+
+      def semantic_ast
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+
+      def string_form
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+
+      def size
+        count = 0
+        nodes = [semantic_ast]
+        until nodes.empty?
+          n = nodes.shift
+          if n
+            count += 1
+            nodes.concat(n.children) if n.respond_to?(:children)
+          end
+        end
+        count
+      end
+
+      def <=>(other)
+        return 1 if other.nil?
+        size <=> other.size
+      end
+
+      def to_s
+        string_form
+      end
+    end
+  end
+end

data/lib/bel_parser/language/specification.rb

@@ -0,0 +1,118 @@
+module BELParser
+  module Language
+    # Specification defines the common behavior of any language specification.
+    # It includes the syntactic and semantic rules of the language.
+    module Specification
+      EMPTY_ARRAY = [].freeze
+
+      def version
+        @version
+      end
+
+      def function(short_or_long_form)
+        @indexed_functions[short_or_long_form]
+      end
+
+      def relationship(short_or_long_form)
+        @indexed_relationships[short_or_long_form]
+      end
+
+      def return_type(return_type)
+        @indexed_return_types[return_type]
+      end
+
+      def value_encoding(value_encoding)
+        @indexed_value_encodings[value_encoding]
+      end
+
+      def functions(*short_or_long_form)
+        if short_or_long_form.empty?
+          @functions.freeze
+        else
+          @indexed_functions.values_at(*short_or_long_form)
+        end
+      end
+
+      def relationships(*short_or_long_form)
+        if short_or_long_form.empty?
+          @relationships.freeze
+        else
+          @indexed_relationships.values_at(*short_or_long_form)
+        end
+      end
+
+      attr_reader :causal_relationships
+      attr_reader :correlative_relationships
+      attr_reader :decreasing_relationships
+      attr_reader :deprecated_relationships
+      attr_reader :direct_relationships
+      attr_reader :directed_relationships
+      attr_reader :genomic_relationships
+      attr_reader :increasing_relationships
+      attr_reader :indirect_relationships
+      attr_reader :listable_relationships
+      attr_reader :self_relationships
+
+      def return_types(*return_types)
+        if return_types.empty?
+          @return_types.freeze
+        else
+          @indexed_return_types.values_at(*return_types)
+        end
+      end
+
+      # @param [Array<#long,#short>] language_objects to be indexed by
+      # +long+ and +short+ method return
+      def index_long_short(language_objects)
+        Hash[
+          language_objects.flat_map do |obj|
+            [[obj.short, obj], [obj.long, obj]]
+          end
+        ]
+      end
+      protected :index_long_short
+
+      # @param [Array<#to_sym>] language_objects to be indexed by
+      # +to_sym+ method return
+      def index_sym(language_objects)
+        Hash[
+          language_objects.map do |obj|
+            [obj.to_sym, obj]
+          end
+        ]
+      end
+      protected :index_sym
+
+      def assign_relationship_categories(relationships)
+        relationships.each do |rel|
+          rel.methods(false).grep(/(.*?)\?/) do |method_name|
+            if rel.method(method_name).call
+              category = method_name.to_s.delete('?')
+              add_relationship_to_category(rel, category)
+            end
+          end
+        end
+
+        freeze_categories
+        nil
+      end
+      protected :assign_relationship_categories
+
+      def add_relationship_to_category(relationship, category)
+        category_ivar = "@#{category}_relationships".to_sym
+        unless instance_variable_defined? category_ivar
+          instance_variable_set(category_ivar, [])
+        end
+        instance_variable_get(category_ivar) << relationship
+      end
+      private :add_relationship_to_category
+
+      def freeze_categories
+        instance_variables.each do |ivar|
+          next unless ivar.to_s =~ /@[a-zA-Z0-9]+_relationships/
+          instance_variable_set(ivar, instance_variable_get(ivar).freeze)
+        end
+      end
+    end
+  end
+end