bel_parser 1.0.0.alpha.1

data/lib/bel_parser/language/semantics/analyzer.rb

@@ -0,0 +1,59 @@
+require 'bel_parser/parsers/ast/node'
+
+module BELParser
+  module Language
+    module Semantics
+      # Recursively apply function semantics to each term.
+      # AST Term Property = :function_semantics
+      def self.apply_function_semantics(term, spec)
+        unless term.is_a?(BELParser::Parsers::AST::Term)
+          raise ArgumentError, "term_ast: expected BELParser::Parsers::AST::Term"
+        end
+
+        function_name = term.function.identifier.string_literal
+        function      = spec.function(function_name.to_sym)
+
+        valid_signature =
+          function.signatures.select do |sig|
+            match(term, sig.semantic_ast, spec).all?(&:success?)
+          end.max
+        if valid_signature
+          term.function_semantics = valid_signature
+          term.arguments.select(&:has_term?).map(&:child).each do |term|
+            apply_function_semantics(term, spec)
+          end
+        else
+          nullify_function_semantics(term)
+        end
+      end
+
+      def self.nullify_function_semantics(term)
+        unless term.is_a?(BELParser::Parsers::AST::Term)
+          raise ArgumentError, "term_ast: expected BELParser::Parsers::AST::Term"
+        end
+
+        term.function_semantics = nil
+        term.arguments.select(&:has_term?).map(&:child).each do |term|
+          nullify_function_semantics(term)
+        end
+      end
+
+      def self.check_term(term, spec)
+        unless term.is_a?(BELParser::Parsers::AST::Term)
+          raise ArgumentError, "term_ast: expected BELParser::Parsers::AST::Term"
+        end
+
+        apply_function_semantics(term, spec)
+
+        semantics = []
+        terms     = [term]
+        while !terms.empty? do
+          term = terms.shift
+          semantics << term.function_semantics
+          terms.concat(term.arguments.select(&:has_term?).map(&:child))
+        end
+        semantics
+      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]
+        while !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,49 @@
+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
+      def function(short_or_long_form)
+        @indexed_functions[short_or_long_form]
+      end
+
+      def return_type(return_type)
+        @indexed_return_types[return_type]
+      end
+
+      def functions(*short_or_long_form)
+        if short_or_long_form.empty?
+          @functions
+        else
+          @indexed_functions.values_at(*short_or_long_form)
+        end
+      end
+
+      def return_types(*return_types)
+        if return_types.empty?
+          @return_types
+        else
+          @indexed_return_types.values_at(*return_types)
+        end
+      end
+
+      def index_functions(functions)
+        Hash[
+          functions.flat_map do |function|
+            [[function.short, function], [function.long, function]]
+          end
+        ]
+      end
+      protected :index_functions
+
+      def index_return_types(return_types)
+        Hash[
+          return_types.map do |return_type|
+            [return_type.to_sym, return_type]
+          end
+        ]
+      end
+      protected :index_return_types
+    end
+  end
+end

data/lib/bel_parser/language/syntax/expression/incomplete_node.rb

@@ -0,0 +1,14 @@
+module BELParser
+  module Language
+    module Syntax
+      module Expression
+        # AST traversal observer that reports if any node is incomplete.
+        class IncompleteNode
+          def update(node)
+            "[#{node.type}] Incomplete #{node.type}." if node.incomplete?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/language/syntax/expression/invalid_term_function.rb

@@ -0,0 +1,22 @@
+module BELParser
+  module Language
+    module Syntax
+      module Expression
+        # AST traversal observer that reports if term functions are invalid
+        # according to a {BELParser::Language::Specification}.
+        class InvalidTermFunction
+          def initialize(specification)
+            @specification = specification
+          end
+
+          def update(node)
+            return unless node.type == :term
+            function_string = node.children[0].children[0].children[0]
+            msg = "[#{node.type}] Invalid function: #{function_string}"
+            msg unless @specification.function(function_string.to_sym)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/language/version1.rb

@@ -0,0 +1,50 @@
+require_relative 'function'
+require_relative 'specification'
+
+# Require all version 1.0 return types
+Dir[
+  File.join(
+    File.dirname(File.expand_path(__FILE__)),
+    'version1', 'return_types', '*.rb')
+].each do |path|
+  require_relative "version1/return_types/#{File.basename(path)}"
+end
+
+# Require all version 1.0 functions.
+Dir[
+  File.join(
+    File.dirname(File.expand_path(__FILE__)),
+    'version1', 'functions', '*.rb')
+].each do |path|
+  require_relative "version1/functions/#{File.basename(path)}"
+end
+
+module BELParser
+  module Language
+    module Version1
+      # Version1Specification defines the BEL, version 1.0 specification.
+      class Specification
+        include BELParser::Language::Specification
+        def initialize
+          # Establish functions
+          function_classes = Version1::Functions.constants.collect do |symbol|
+            const = Version1::Functions.const_get(symbol)
+            const if
+              const.respond_to?(:short) &&
+              const.respond_to?(:long)
+          end
+          @functions = function_classes.compact
+          @indexed_functions = index_functions(@functions)
+
+          # Establish return types
+          ret_classes = Version1::ReturnTypes.constants.collect do |symbol|
+            const = Version1::ReturnTypes.const_get(symbol)
+            const if const.respond_to?(:subtypes)
+          end
+          @return_types = ret_classes.compact
+          @indexed_return_types = index_return_types(@return_types)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+require_relative '../../version1'
+require_relative '../../function'
+require_relative '../../signature'
+require_relative '../../semantic_ast'
+
+module BELParser
+  module Language
+    module Version1
+      module Functions
+        # Abundance: Denotes the abundance of an entity
+        class Abundance
+          extend Function
+
+          SHORT       = :a
+          LONG        = :abundance
+          RETURN_TYPE = BELParser::Language::Version1::ReturnTypes::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
+  
+            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(
+                      identifier(
+                        has_namespace,
+                        namespace_of(:*))),
+                    value(
+                      value_type(
+                        has_encoding,
+                        encoding_of(:Abundance))))))              
+              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/functions/biological_process.rb

@@ -0,0 +1,85 @@
+require_relative '../../version1'
+require_relative '../../function'
+require_relative '../../signature'
+require_relative '../../semantic_ast'
+
+module BELParser
+  module Language
+    module Version1
+      module Functions
+        # BiologicalProcess: Denotes a process or population of events
+        class BiologicalProcess
+          extend Function
+
+          SHORT       = :bp
+          LONG        = :biologicalProcess
+          RETURN_TYPE = BELParser::Language::Version1::ReturnTypes::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
+  
+            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(
+                      identifier(
+                        has_namespace,
+                        namespace_of(:*))),
+                    value(
+                      value_type(
+                        has_encoding,
+                        encoding_of(:BiologicalProcess))))))              
+              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

data/lib/bel_parser/language/version1/functions/catalytic_activity.rb

@@ -0,0 +1,110 @@
+require_relative '../../version1'
+require_relative '../../function'
+require_relative '../../signature'
+require_relative '../../semantic_ast'
+
+module BELParser
+  module Language
+    module Version1
+      module Functions
+        # CatalyticActivity: Denotes the frequency or abundance of events where a member acts as an enzymatic catalyst of biochecmial reactions
+        class CatalyticActivity
+          extend Function
+
+          SHORT       = :cat
+          LONG        = :catalyticActivity
+          RETURN_TYPE = BELParser::Language::Version1::ReturnTypes::CatalyticActivity
+          DESCRIPTION = 'Denotes the frequency or abundance of events where a member acts as an enzymatic catalyst of biochecmial reactions'.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
+  
+            class CatalyticActivityOfComplexAbundanceSignature
+              extend BELParser::Language::Signature
+
+              private_class_method :new
+
+              AST = BELParser::Language::Semantics::Builder.build do
+                term(
+                function(
+                  identifier(
+                    function_of(CatalyticActivity))),
+                argument(
+                  term(
+                    function(
+                      identifier(
+                        return_type_of(BELParser::Language::Version1::ReturnTypes::ComplexAbundance))))))              
+              end
+              private_constant :AST
+
+              STRING_FORM = 'catalyticActivity(F:complexAbundance)catalyticActivity'.freeze
+              private_constant :STRING_FORM
+
+              def self.semantic_ast
+                AST
+              end
+
+              def self.string_form
+                STRING_FORM
+              end
+            end
+  
+            class CatalyticActivityOfProteinAbundanceSignature
+              extend BELParser::Language::Signature
+
+              private_class_method :new
+
+              AST = BELParser::Language::Semantics::Builder.build do
+                term(
+                function(
+                  identifier(
+                    function_of(CatalyticActivity))),
+                argument(
+                  term(
+                    function(
+                      identifier(
+                        return_type_of(BELParser::Language::Version1::ReturnTypes::ProteinAbundance))))))              
+              end
+              private_constant :AST
+
+              STRING_FORM = 'catalyticActivity(F:proteinAbundance)catalyticActivity'.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