bel_parser 1.0.0.alpha.27-java

data/lib/bel_parser/language/syntax.rb

@@ -0,0 +1,38 @@
+require_relative 'syntax_function'
+require_relative 'syntax_error'
+require_relative 'syntax_warning'
+
+module BELParser
+  module Language
+    # Syntax module aggregates the generic {SyntaxFunction}
+    # implementations that apply to all
+    # {BELParser::Language::Specification BEL specifications}.
+    module Syntax
+      def self.syntax_functions
+        constants.collect do |symbol|
+          const = const_get(symbol)
+          const if
+            const.respond_to?(:include?) &&
+            const.include?(SyntaxFunction)
+        end.compact
+      end
+
+      # Valid defines a {SyntaxResult} that indicates successful syntax
+      # validation.
+      class Valid < SyntaxResult
+        def msg
+          'Syntax is valid.'
+        end
+      end
+    end
+  end
+end
+
+# Require all generic syntax functions.
+Dir[
+  File.join(
+    File.dirname(File.expand_path(__FILE__)),
+    'syntax', '*.rb')
+].each do |path|
+  require_relative "syntax/#{File.basename(path)}"
+end

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

@@ -0,0 +1,39 @@
+require 'bel_parser/parsers/ast/node'
+
+module BELParser
+  module Language
+    module Syntax
+      # InvalidFunction represents a syntax error with invalid function name
+      # according to a BEL specification.
+      class InvalidFunction
+        include SyntaxFunction
+
+        private_class_method :new
+
+        def self.map(func_node, spec, _namespaces)
+          return nil unless func_node.is_a?(BELParser::Parsers::AST::Function)
+
+          function_name = func_node.identifier.string_literal
+          unless spec.function(function_name.to_sym)
+            InvalidFunctionSyntaxError.new(func_node, spec, function_name)
+          end
+        end
+      end
+
+      # InvalidFunctionSyntaxError indicates a function name was invalid.
+      class InvalidFunctionSyntaxError < SyntaxError
+        # Gets the invalid function literal.
+        attr_reader :invalid_function
+
+        def initialize(function, spec, invalid_function)
+          super(function, spec)
+          @invalid_function = invalid_function
+        end
+
+        def msg
+          %(Invalid function "#{invalid_function}".)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'bel_parser/parsers/ast/node'
+
+module BELParser
+  module Language
+    module Syntax
+      # InvalidRelationship represents a syntax error with invalid
+      # relationship according to a BEL specification.
+      class InvalidRelationship
+        include SyntaxFunction
+
+        private_class_method :new
+
+        def self.map(stmt_node, spec, _namespaces)
+          return nil unless stmt_node.is_a?(BELParser::Parsers::AST::Statement)
+
+          rel_name = stmt_node.relationship.string_literal
+          return nil if rel_name.nil?
+
+          unless spec.relationship(rel_name.to_sym)
+            InvalidRelationshipSyntaxError.new(stmt_node, spec, rel_name)
+          end
+        end
+      end
+
+      # InvalidRelationshipSyntaxError indicates a relationship was invalid.
+      class InvalidRelationshipSyntaxError < SyntaxError
+        # Gets the relationship literal that was invalid according to a
+        # BEL specification.
+        attr_reader :relationship
+
+        def initialize(stmt_node, spec, relationship)
+          super(stmt_node, spec)
+          @relationship = relationship
+        end
+
+        def msg
+          %(Invalid relationship "#{relationship}".)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require 'bel_parser/parsers/ast/node'
+
+module BELParser
+  module Language
+    module Syntax
+      # Undefined namespace finds parameter prefixes that reference an
+      # undefined namespace.
+      class UndefinedNamespace
+        include SyntaxFunction
+
+        private_class_method :new
+
+        def self.map(prefix_node, spec, namespaces)
+          return nil unless prefix_node.is_a?(BELParser::Parsers::AST::Prefix)
+
+          prefix_identifier = prefix_node.identifier
+          return nil if prefix_identifier.nil?
+
+          prefix = prefix_identifier.string_literal
+          unless namespaces[prefix]
+            UndefinedNamespaceError.new(prefix_node, spec, prefix, namespaces)
+          end
+        end
+      end
+
+      # UndefinedNamespaceError indicates a parameter prefix is referencing
+      # an undefined namespace.
+      class UndefinedNamespaceError < SyntaxError
+        # Gets the invalid prefix.
+        attr_reader :invalid_prefix
+        # Gets the defined namespaces.
+        attr_reader :defined_namespaces
+
+        def initialize(prefix_node, spec, invalid_prefix, defined_namespaces)
+          super(prefix_node, spec)
+          @invalid_prefix     = invalid_prefix
+          @defined_namespaces = defined_namespaces.dup
+        end
+
+        def msg
+          <<-MSG.gsub(/ {10}/, '')
+            Undefined namespace "#{invalid_prefix}".
+            Defined namespaces are: #{defined_namespaces.keys.join(', ')}
+          MSG
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'bel_parser/parsers/ast/node'
+require 'bel_parser/quoting'
+
+module BELParser
+  module Language
+    module Syntax
+      # Undefined namespace value finds values that are missing from their
+      # purported namespaces.
+      class UndefinedNamespaceValue
+        extend BELParser::Quoting
+        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 = unquote(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(value_node, spec, value)
+          super(value_node, spec)
+          @value = value
+        end
+
+        def msg
+          prefix = @expression_node.prefix
+          %(Undefined namespace value "#@value" for namespace "#{prefix}".)
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/language/syntax_error.rb

@@ -0,0 +1,32 @@
+require_relative 'syntax_result'
+
+module BELParser
+  module Language
+    module Syntax
+      # SyntaxError defines a {SyntaxResult} that should be regarded as an
+      # error with the expression.
+      class SyntaxError < SyntaxResult
+        def initialize(expression_node, specification)
+          super(expression_node, specification)
+        end
+
+        # @abstract Subclass and override {#msg} to provide the message.
+        def msg
+          raise NotImplementedError, "#{__method__} is not implemented."
+        end
+
+        def success?
+          false
+        end
+
+        def failure?
+          true
+        end
+
+        def to_s
+          "Error: #{msg}"
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/language/syntax_function.rb

@@ -0,0 +1,16 @@
+module BELParser
+  module Language
+    module Syntax
+      # SyntaxFunction provides a {#map} function that maps a
+      # {BELParser::Parsers::AST::Node} to one or more
+      # {SyntaxResult syntax results}.
+      module SyntaxFunction
+        # @abstract Include {SyntaxFunction} and override {#map} to check
+        # expression syntax.
+        def self.map(_expression_ast, _spec, _namespaces)
+          raise NotImplementedError, "#{__method__} is not implemented."
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/language/syntax_result.rb

@@ -0,0 +1,32 @@
+module BELParser
+  module Language
+    module Syntax
+      # SyntaxResult represents the result of running a {SyntaxFunction}.
+      class SyntaxResult
+        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
+          raise NotImplementedError, "#{__method__} is not implemented."
+        end
+
+        def to_s
+          "Info: #{msg}"
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/language/syntax_warning.rb

@@ -0,0 +1,27 @@
+require_relative 'syntax_result'
+
+module BELParser
+  module Language
+    module Syntax
+      # SyntaxWarning defines a {SyntaxResult} that should be regarded as an
+      # warning with the expression.
+      class SyntaxWarning < SyntaxResult
+        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/version1_0.rb

@@ -0,0 +1,20 @@
+require_relative 'function'
+require_relative 'specification'
+require_relative 'base_specification'
+
+module BELParser
+  module Language
+    module Version1_0
+      # Version1_0 specification defines the BEL 1.0 specification.
+      class Specification < BaseSpecification
+        BaseSpecification.load_version_path('version1_0')
+
+        def initialize
+          @version = '1.0'.freeze
+          load_language_constants(Version1_0)
+          freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+require_relative '../../version1_0'
+require_relative '../../function'
+require_relative '../../signature'
+require_relative '../../semantics'
+
+module BELParser
+  module Language
+    module Version1_0
+      module Functions
+        # Abundance: Denotes the abundance of an entity
+        class Abundance
+          extend Function
+
+          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
+            SHORT
+          end
+
+          def self.long
+            LONG
+          end
+
+          def self.return_type
+            RETURN_TYPE
+          end
+
+          def self.description
+            DESCRIPTION
+          end
+
+          def self.signatures
+            SIGNATURES
+          end
+
+          module Signatures
+            # AbundanceSignature
+            class AbundanceSignature
+              extend BELParser::Language::Signature
+
+              private_class_method :new
+
+              AST = BELParser::Language::Semantics::Builder.build do
+                term(
+                  function(
+                    identifier(
+                      function_of(Abundance))),
+                  argument(
+                    parameter(
+                      prefix(
+                        has_namespace,
+                        namespace_of(:*)),
+                      value(
+                        has_encoding,
+                        encoding_of(A_ENC)))))
+              end
+              private_constant :AST
+
+              STRING_FORM = 'abundance(E:abundance)abundance'.freeze
+              private_constant :STRING_FORM
+
+              def self.semantic_ast
+                AST
+              end
+
+              def self.string_form
+                STRING_FORM
+              end
+            end
+          end
+
+          SIGNATURES = Signatures.constants.map do |const|
+            Signatures.const_get(const)
+          end.freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+require_relative '../../version1_0'
+require_relative '../../function'
+require_relative '../../signature'
+require_relative '../../semantics'
+
+module BELParser
+  module Language
+    module Version1_0
+      module Functions
+        # BiologicalProcess: Denotes a process or population of events
+        class BiologicalProcess
+          extend Function
+
+          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
+            SHORT
+          end
+
+          def self.long
+            LONG
+          end
+
+          def self.return_type
+            RETURN_TYPE
+          end
+
+          def self.description
+            DESCRIPTION
+          end
+
+          def self.signatures
+            SIGNATURES
+          end
+
+          module Signatures
+            # BiologicalProcessSignature
+            class BiologicalProcessSignature
+              extend BELParser::Language::Signature
+
+              private_class_method :new
+
+              AST = BELParser::Language::Semantics::Builder.build do
+                term(
+                  function(
+                    identifier(
+                      function_of(BiologicalProcess))),
+                  argument(
+                    parameter(
+                      prefix(
+                        has_namespace,
+                        namespace_of(:*)),
+                      value(
+                        has_encoding,
+                        encoding_of(B_ENC)))))
+              end
+              private_constant :AST
+
+              STRING_FORM = 'biologicalProcess(E:biologicalProcess)biologicalProcess'.freeze
+              private_constant :STRING_FORM
+
+              def self.semantic_ast
+                AST
+              end
+
+              def self.string_form
+                STRING_FORM
+              end
+            end
+          end
+
+          SIGNATURES = Signatures.constants.map do |const|
+            Signatures.const_get(const)
+          end.freeze
+        end
+      end
+    end
+  end
+end