bel_parser 1.0.0.alpha.27-java

data/lib/bel_parser/language/covalent_protein_modification.rb

@@ -0,0 +1,56 @@
+module BELParser
+  module Language
+    # CovalentProteinModification defines a controlled vocabulary of
+    # post-translational protein modifications.
+    #
+    # see https://en.wikipedia.org/wiki/Post-translational_modification
+    module CovalentProteinModification
+      Acetylation     = [:Acetylation, :A].freeze
+      Farnesylation   = [:Farnesylation, :F].freeze
+      Glycosylation   = [:Glycosylation, :G].freeze
+      Hydroxylation   = [:Hydroxylation, :H].freeze
+      Methylation     = [:Methylation, :M].freeze
+      Phosphorylation = [:Phosphorylation, :P].freeze
+      Ribosylation    = [:Ribosylation, :R].freeze
+      Sumoylation     = [:Sumoylation, :S].freeze
+      Ubiquitination  = [:Ubiquitination, :U].freeze
+
+      # Determines if +sym+ represents a covalent protein modification.
+      #
+      # @param [#to_sym] sym covalent protein modification code
+      # @return [Boolean] +true+ if +sym+ code is included in supported
+      # covalent protein modifications; +false+ if not supported
+      def self.includes?(sym)
+        @hash.key?(sym.to_sym)
+      end
+
+      # Gets all supported covalent protein modification.
+      def self.names
+        @names
+      end
+
+      # Gets all supported covalent protein modification (i.e. name, 1-Letter).
+      def self.values
+        @values
+      end
+
+      unless defined? @hash
+        @hash = {}
+        constants.map(&method(:const_get)).each do |values|
+          @hash.update(
+            Hash[values.map { |v| [v, values.first] }]
+          )
+        end
+        @hash.freeze
+      end
+
+      unless defined? @names
+        @names = constants.map(&method(:const_get)).map(&:first).sort.freeze
+      end
+
+      unless defined? @values
+        @values = constants.map(&method(:const_get)).map(&:to_a).flatten.freeze
+      end
+    end
+  end
+end

data/lib/bel_parser/language/expression_validator.rb

@@ -0,0 +1,68 @@
+require_relative 'syntax'
+require_relative 'semantics'
+require_relative 'apply_namespace_encoding'
+
+module BELParser
+  module Language
+    # ExpressionValidator validates the syntax and semantics of BEL expressions
+    # when supplied a {BELParser::Language::Specification} and Hash of
+    # namespaces.
+    class ExpressionValidator
+      def initialize(spec, namespaces, resource_reader)
+        @spec                = spec
+        @namespaces          = namespaces || {}
+        @syntax_functions    = Syntax.syntax_functions
+        @semantics_functions = Semantics.semantics_functions
+        @transform           =
+          ApplyNamespaceEncoding.new(@spec, @namespaces, resource_reader)
+      end
+
+      # Validate the syntax and semantics of
+      # {BELParser::Parsers::AST::Node expression_node}.
+      #
+      # @param  [BELParser::Parsers::AST::Node] expression_node to validate
+      # @return [BELParser::Language::Syntax::SyntaxResult] syntax results
+      def validate(expression_node)
+        @transform.process(expression_node)
+        results = syntax(expression_node)
+        results << Syntax::Valid.new(expression_node, @spec) if results.empty?
+        results.concat(semantics(expression_node))
+        results
+      end
+
+      private
+
+      def syntax(expression_node)
+        expression_node.traverse.flat_map do |node|
+          @syntax_functions.map { |func| func.map(node, @spec, @namespaces) }
+        end.compact
+      end
+
+      def semantics(expression_node)
+        semantic_results =
+          expression_node.traverse.flat_map do |node|
+            @semantics_functions.flat_map { |func| func.map(node, @spec, @namespaces) }
+          end.compact
+        sigmap_results, other_results =
+          semantic_results.partition do |result|
+            result.is_a?(Semantics::SignatureMappingSuccess) ||
+              result.is_a?(Semantics::SignatureMappingWarning)
+          end
+        expression_node
+          .traverse
+          .select do |node|
+            node.is_a?(BELParser::Parsers::AST::Term)
+          end
+          .map do |term_node|
+            sigmap_term =
+              sigmap_results
+              .select { |res| res.expression_node == term_node }
+            unless sigmap_term.any?(&:success?)
+              other_results.concat(sigmap_term)
+            end
+          end
+        other_results
+      end
+    end
+  end
+end

data/lib/bel_parser/language/function.rb

@@ -0,0 +1,67 @@
+module BELParser
+  module Language
+    # Function allows you to describe the type of BEL Term.
+    #
+    # BEL Terms are composed of BEL Functions and entity definitions
+    # referenced using BEL Namespace identifiers. Each BEL Term represents
+    # either an abundance of a biological entity, the abundance of human AKT1
+    # for example, or a biological process such as cardiomyopathy.
+    module Function
+      def short
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+
+      def long
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+
+      def return_type
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+
+      def description
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+
+      def signatures
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+
+      # Indicates whether this function is deprecated. Override in your
+      # function to mark as deprecated.
+      #
+      # @return [Boolean] false
+      def deprecated?
+        false
+      end
+
+      def ===(other)
+        return false if other.nil?
+        short == other || long == other
+      end
+
+      def to_sym(form = :short)
+        value = _form_value(form)
+        return nil unless value
+        value.to_s
+      end
+
+      def to_s(form = :short)
+        value = _form_value(form)
+        return nil unless value
+        value.to_s
+      end
+
+      private
+
+      def _form_value(form = :short)
+        case form
+        when :short
+          short
+        when :long
+          long
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/language/relationship.rb

@@ -0,0 +1,102 @@
+module BELParser
+  module Language
+    # Relationship allows you to describe the type of BEL Relationship.
+    #
+    # BEL Relationships represent an interaction between a subject and object
+    # in the BEL expression.
+    module Relationship
+      def short
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+
+      def long
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+
+      def description
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+
+      # Indicates whether this relationship is deprecated. Override in your
+      # relationship to mark as deprecated.
+      #
+      # @return [Boolean] false
+      def deprecated?
+        false
+      end
+
+      def causal?
+        false
+      end
+
+      def correlative?
+        false
+      end
+
+      def decreasing?
+        false
+      end
+
+      def direct?
+        false
+      end
+
+      def directed?
+        false
+      end
+
+      def genomic?
+        false
+      end
+
+      def increasing?
+        false
+      end
+
+      def indirect?
+        false
+      end
+
+      def injected?
+        false
+      end
+
+      def listable?
+        false
+      end
+
+      def self?
+        false
+      end
+
+      def ==(other)
+        return true if equal?(other)
+        return false if other.nil?
+        short == other || long == other
+      end
+
+      def to_sym(form = :short)
+        value = _form_value(form)
+        return nil unless value
+        value.to_s
+      end
+
+      def to_s(form = :short)
+        value = _form_value(form)
+        return nil unless value
+        value.to_s
+      end
+
+      private
+
+      def _form_value(form = :short)
+        case form
+        when :short
+          short
+        when :long
+          long
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/language/semantics.rb

@@ -0,0 +1,40 @@
+require_relative 'semantics_match'
+require_relative 'semantics_ast'
+require_relative 'semantics_result'
+require_relative 'semantics_warning'
+require_relative 'semantics_function'
+
+module BELParser
+  module Language
+    # Semantics module aggregates the generic {SemanticsFunction}
+    # implementations that apply to all
+    # {BELParser::Language::Specification BEL specifications}.
+    module Semantics
+      def self.semantics_functions
+        constants.collect do |symbol|
+          const = const_get(symbol)
+          const if
+            const.respond_to?(:include?) &&
+            const.include?(SemanticsFunction)
+        end.compact
+      end
+
+      # Valid defines a {SemanticsResult} that indicates successful semantic
+      # validation.
+      class Valid < SemanticsResult
+        def msg
+          'Semantics are valid.'
+        end
+      end
+    end
+  end
+end
+
+# Require all semantics functions.
+Dir[
+  File.join(
+    File.dirname(File.expand_path(__FILE__)),
+    'semantics', '*.rb')
+].each do |path|
+  require_relative "semantics/#{File.basename(path)}"
+end

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

@@ -0,0 +1,65 @@
+require 'bel_parser/parsers/ast/node'
+
+module BELParser
+  module Language
+    module Semantics
+      # DeeplyNestedStatement implements a {SemanticsFunction} that maps a
+      # {BELParser::Parsers::AST::NestedStatement} to {SemanticsWarning} if
+      # the number of nested statements exceeds
+      # {DeeplyNestedStatement::NESTING_THRESHOLD}.
+      #
+      # @see DeeplyNestedStatement::NESTING_THRESHOLD
+      class DeeplyNestedStatement
+        include SemanticsFunction
+
+        # Represents how many nested statments must be exceeded before a
+        # {SemanticsWarning} results.
+        NESTING_THRESHOLD = 1
+
+        private_class_method :new
+
+        def self.map(node, spec, _namespaces)
+          return nil unless node.is_a?(BELParser::Parsers::AST::NestedStatement)
+
+          nested_number = count_nested_statements(node)
+          DeeplyNestedStatementWarning.new(
+            node,
+            spec,
+            NESTING_THRESHOLD,
+            nested_number) if nested_number > NESTING_THRESHOLD
+        end
+
+        def self.count_nested_statements(node)
+          node
+            .traverse
+            .select { |n| n.is_a?(BELParser::Parsers::AST::Object) }
+            .reduce(0) do |sum, object|
+              sum += 1 if object.statement?
+              sum
+            end
+        end
+      end
+
+      # DeeplyNestedStatementWarning defines a {SemanticsWarning} that
+      # indicates the nested statement threshold was exceeded.
+      #
+      # @see DeeplyNestedStatement::NESTING_THRESHOLD
+      class DeeplyNestedStatementWarning < SemanticsWarning
+        attr_reader :nested_threshold, :nested_number
+
+        def initialize(stmt_node, spec, nested_threshold, nested_number)
+          super(stmt_node, spec)
+          @nested_number    = nested_number
+          @nested_threshold = nested_threshold
+        end
+
+        def to_s
+          <<-MSG.gsub(/ {12}/, '').delete("\n")
+            Statement contains more than #{nested_threshold} nested statements
+             (#{nested_number} nested statements).
+          MSG
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'bel_parser/parsers/ast/node'
+
+module BELParser
+  module Language
+    module Semantics
+      # FunctionDeprecation implements a {SemanticsFunction} that maps a
+      # {BELParser::Parsers::AST::Function} to a {SemanticsWarning} if the
+      # referenced function is deprecated for the
+      # {BELParser::Language::Specification}.
+      class FunctionDeprecation
+        include SemanticsFunction
+
+        private_class_method :new
+
+        def self.map(node, spec, _namespaces)
+          return nil unless node.is_a?(BELParser::Parsers::AST::Function)
+
+          function_name = node.identifier.string_literal
+          func          = spec.function(function_name.to_sym)
+          return nil unless func
+
+          FunctionDeprecationWarning.new(node, spec, func) if func.deprecated?
+        end
+      end
+
+      # Represents a {SemanticsWarning} when a
+      # {BELParser::Parsers::AST::Function} references a deprecated function
+      # for the {BELParser::Language::Specification}.
+      class FunctionDeprecationWarning < SemanticsWarning
+        attr_reader :deprecated_function
+
+        def initialize(function_node, spec, deprecated_function)
+          super(function_node, spec)
+          @deprecated_function = deprecated_function
+        end
+
+        def to_s
+          %(Function "#{deprecated_function}" is deprecated.)
+        end
+      end
+    end
+  end
+end