bel_parser 1.0.0.alpha.12 → 1.0.0.alpha.13

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_result.rb

@@ -1,7 +1,8 @@
 module BELParser
   module Language
     module Semantics
-      # SemanticsResult represents the result of running a {SemanticsFunction}.
+      # SemanticsResult represents the successful outcome of applying a
+      # {SemanticsFunction}.
       class SemanticsResult
         attr_reader :expression_node, :specification
 
@@ -10,9 +11,17 @@ module BELParser
           @specification   = specification
         end
 
+        def success?
+          true
+        end
+
+        def failure?
+          false
+        end
+
         # @abstract Subclass and override {#msg} to provide the message.
         def msg
-          raise NotImplementedError, "#{__method__} is not implemented."
+          "Successful semantic validation of #{@expression_node.type}."
         end
 
         def to_s

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

@@ -10,6 +10,14 @@ module BELParser
           super(expression_node, specification)
         end
 
+        def success?
+          false
+        end
+
+        def failure?
+          true
+        end
+
         def to_s
           "Warning: #{msg}"
         end

data/lib/bel_parser/language/specification.rb

@@ -5,6 +5,10 @@ module BELParser
     module Specification
       EMPTY_ARRAY = [].freeze
 
+      def version
+        @version
+      end
+
       def function(short_or_long_form)
         @indexed_functions[short_or_long_form]
       end
@@ -17,6 +21,10 @@ module BELParser
         @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
@@ -33,6 +41,18 @@ module BELParser
         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
@@ -41,54 +61,6 @@ module BELParser
         end
       end
 
-      def syntax
-        @syntax
-      end
-
-      def causal_relationships
-        @causal_relationships || EMPTY_ARRAY
-      end
-
-      def correlative_relationships
-        @correlative_relationships || EMPTY_ARRAY
-      end
-
-      def decreasing_relationships
-        @decreasing_relationships || EMPTY_ARRAY
-      end
-
-      def deprecated_relationships
-        @deprecated_relationships || EMPTY_ARRAY
-      end
-
-      def direct_relationships
-        @direct_relationships || EMPTY_ARRAY
-      end
-
-      def directed_relationships
-        @directed_relationships || EMPTY_ARRAY
-      end
-
-      def genomic_relationships
-        @genomic_relationships || EMPTY_ARRAY
-      end
-
-      def increasing_relationships
-        @increasing_relationships || EMPTY_ARRAY
-      end
-
-      def indirect_relationships
-        @indirect_relationships || EMPTY_ARRAY
-      end
-
-      def listable_relationships
-        @listable_relationships || EMPTY_ARRAY
-      end
-
-      def self_relationships
-        @self_relationships || EMPTY_ARRAY
-      end
-
       # @param [Array<#long,#short>] language_objects to be indexed by
       # +long+ and +short+ method return
       def index_long_short(language_objects)
@@ -116,19 +88,30 @@ module BELParser
           rel.methods(false).grep(/(.*?)\?/) do |method_name|
             if rel.method(method_name).call
               category = method_name.to_s.delete('?')
-              category_ivar = "@#{category}_relationships".to_sym
-              unless instance_variable_defined? category_ivar
-                instance_variable_set(category_ivar, [])
-              end
-              instance_variable_get(category_ivar) << rel
+              add_relationship_to_category(rel, category)
             end
           end
         end
+
+        freeze_categories
+        nil
       end
       protected :assign_relationship_categories
 
-      def version
-        @version
+      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

data/lib/bel_parser/language/syntax/undefined_namespace_value.rb

@@ -0,0 +1,43 @@
+require 'bel_parser/parsers/ast/node'
+
+module BELParser
+  module Language
+    module Syntax
+      # Undefined namespace value finds values that are missing from their
+      # purported namespaces.
+      class UndefinedNamespaceValue
+        include SyntaxFunction
+
+        private_class_method :new
+
+        def self.map(value_node, spec, namespaces)
+          return nil unless value_node.is_a?(BELParser::Parsers::AST::Value)
+          return nil unless value_node.namespace
+
+          unless value_node.namespace_value
+            value = value_node.children[0].string_literal
+            UndefinedNamespaceValueWarning.new(value_node, spec, value)
+          end
+        end
+      end
+
+      # UndefinedNamespaceValueWarning indicates a value is missing from a
+      # namespace.
+      class UndefinedNamespaceValueWarning < SyntaxWarning
+        # Gets the undefined value.
+        attr_reader :undefined_value
+
+        def initialize(prefix_node, spec, undefined_value)
+          super(prefix_node, spec)
+          @undefined_value = undefined_value
+        end
+
+        def msg
+          <<-MSG.gsub(/ {10}/, '')
+            Undefined namespace value "#{undefined_value}".
+          MSG
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/language/syntax_error.rb

@@ -15,6 +15,14 @@ module BELParser
           raise NotImplementedError, "#{__method__} is not implemented."
         end
 
+        def success?
+          false
+        end
+
+        def failure?
+          true
+        end
+
         def to_s
           "Error: #{msg}"
         end

data/lib/bel_parser/language/syntax_result.rb

@@ -10,6 +10,14 @@ module BELParser
           @specification   = specification
         end
 
+        def success?
+          true
+        end
+
+        def failure?
+          false
+        end
+
         # @abstract Subclass and override {#msg} to provide the message.
         def msg
           raise NotImplementedError, "#{__method__} is not implemented."

data/lib/bel_parser/language/syntax_warning.rb

@@ -6,11 +6,16 @@ module BELParser
       # SyntaxWarning defines a {SyntaxResult} that should be regarded as an
       # warning with the expression.
       class SyntaxWarning < SyntaxResult
-        attr_reader :target_node
-
-        def initialize(expression_node, specification, target_node)
+        def initialize(expression_node, specification)
           super(expression_node, specification)
-          @target_node = target_node
+        end
+
+        def success?
+          false
+        end
+
+        def failure?
+          true
         end
 
         def to_s

data/lib/bel_parser/language/version1_0/functions/abundance.rb

@@ -14,6 +14,7 @@ module BELParser
           SHORT       = :a
           LONG        = :abundance
           RETURN_TYPE = BELParser::Language::Version1_0::ReturnTypes::Abundance
+          A_ENC       = Version1_0::ValueEncodings::Abundance
           DESCRIPTION = 'Denotes the abundance of an entity'.freeze
 
           def self.short
@@ -51,13 +52,11 @@ module BELParser
                   argument(
                     parameter(
                       prefix(
-                        identifier(
-                          has_namespace,
-                          namespace_of(:*))),
+                        has_namespace,
+                        namespace_of(:*)),
                       value(
-                        value_type(
-                          has_encoding,
-                          encoding_of(:Abundance))))))
+                        has_encoding,
+                        encoding_of(A_ENC)))))
               end
               private_constant :AST
 

data/lib/bel_parser/language/version1_0/functions/biological_process.rb

@@ -14,6 +14,7 @@ module BELParser
           SHORT       = :bp
           LONG        = :biologicalProcess
           RETURN_TYPE = BELParser::Language::Version1_0::ReturnTypes::BiologicalProcess
+          B_ENC       = Version1_0::ValueEncodings::BiologicalProcess
           DESCRIPTION = 'Denotes a process or population of events'.freeze
 
           def self.short
@@ -51,13 +52,11 @@ module BELParser
                   argument(
                     parameter(
                       prefix(
-                        identifier(
-                          has_namespace,
-                          namespace_of(:*))),
+                        has_namespace,
+                        namespace_of(:*)),
                       value(
-                        value_type(
-                          has_encoding,
-                          encoding_of(:BiologicalProcess))))))
+                        has_encoding,
+                        encoding_of(B_ENC)))))
               end
               private_constant :AST
 

data/lib/bel_parser/language/version1_0/functions/complex_abundance.rb

@@ -14,6 +14,7 @@ module BELParser
           SHORT       = :complex
           LONG        = :complexAbundance
           RETURN_TYPE = BELParser::Language::Version1_0::ReturnTypes::ComplexAbundance
+          C_ENC       = Version1_0::ValueEncodings::ComplexAbundance
           DESCRIPTION = 'Denotes the abundance of a molecular
           omplex'.freeze
 
@@ -52,17 +53,15 @@ module BELParser
                   argument(
                     parameter(
                       prefix(
-                        identifier(
-                          has_namespace,
-                          namespace_of(:*))),
+                        has_namespace,
+                        namespace_of(:*)),
                       value(
-                        value_type(
-                          has_encoding,
-                          encoding_of(:Abundance))))))
+                        has_encoding,
+                        encoding_of(C_ENC)))))
               end
               private_constant :AST
 
-              STRING_FORM = 'complexAbundance(E:abundance)complexAbundance'.freeze
+              STRING_FORM = 'complexAbundance(E:complexAbundance)complexAbundance'.freeze
               private_constant :STRING_FORM
 
               def self.semantic_ast