bel_parser 1.0.0.alpha.5 → 1.0.0.alpha.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6ddb397fcf12e876d078e3a6a239479e0f3913d3
-  data.tar.gz: 65b412663bfd2e0d19fe5a3e6224f9776881cb3a
+  metadata.gz: 31d99776d9e14c8680ec557fcc2e9e94136b90dc
+  data.tar.gz: 0764321e9c0d762d5a4186301f62c4f21b56431c
 SHA512:
-  metadata.gz: d7156e7a60e8bd45615b8f8d8651071b08187c30bfea4c5726600ea277b0d47b8981ef255a023b0f086f4619f4096c622e9b1cc9bedd40e41321e1542f881cc0
-  data.tar.gz: d16d66850d29718f589e772ed0a5fbc32221d3ce7157c103ca6e6969a0ffdbc51e559ad7bb1e31c7200a0dcf44160f9346c028760413eaa5a276a2fa32bef274
+  metadata.gz: 4d8915205e38ae41098e1c4468b7a54b7d07f23b20f6667d8ab17fbbd7371504402e369122d3e6a91d3adb1148d824578732328f457531956b729402b5401d1f
+  data.tar.gz: 528a2bad2581e21df25812804b56d7c366d23f1ee18524767aac5cf8e518b4d1d58952c75763e7893d760b66809b3e15d0d92b0091dda4b6a56bf6d28ebf1146

data/VERSION

@@ -1 +1 @@
-1.0.0.alpha.5
+1.0.0.alpha.6

data/bin/bel2_validator

@@ -11,7 +11,7 @@ end
 namespaces = Hash[ARGV[1..-1].map { |ns| ns.split('=') }]
 
 require 'bel_parser'
-require 'bel_parser/expression/term_validator'
-BELParser::Expression::TermValidator.new(ARGV.first, namespaces).each($stdin) do |res|
+require 'bel_parser/expression/validator'
+BELParser::Expression::Validator.new(ARGV.first, namespaces).each($stdin) do |res|
   puts res.map { |r| "#{r}\n" }.join.each_line.map { |l| "  #{l}" }.join
 end

data/lib/bel_parser/expression/parser.rb

@@ -14,7 +14,7 @@ module BELParser
       FILTER = BELParser::ASTFilter.new(
         :parameter,
         :term,
-        :statement_simple,
+        :simple_statement,
         :observed_term,
         :nested_statement
       )

data/lib/bel_parser/expression/{term_validator.rb → validator.rb}

@@ -7,11 +7,16 @@ require_relative '../language/expression_validator'
 module BELParser
   module Expression
     # Parser for BEL Expression.
-    class TermValidator
+    class Validator
       include BELParser::Parsers::Common
       include BELParser::Parsers::Expression
 
-      FILTER = BELParser::ASTFilter.new(:term)
+      FILTER = BELParser::ASTFilter.new(
+        :parameter,
+        :term,
+        :observed_term,
+        :simple_statement,
+        :nested_statement)
 
       def initialize(specification_version, namespaces)
         @spec      = BELParser::Language.specification(specification_version)
@@ -42,7 +47,7 @@ if __FILE__ == $PROGRAM_NAME
     exit 1
   end
   namespaces = Hash[ARGV[1..-1].map { |ns| ns.split('=') }]
-  BELParser::Expression::TermValidator.new(ARGV.first, namespaces).each($stdin) do |res|
+  BELParser::Expression::Validator.new(ARGV.first, namespaces).each($stdin) do |res|
     res.each do |res|
       puts res.each_line.map { |l| "  #{l}" }.join
     end

data/lib/bel_parser/language/expression_validator.rb

@@ -11,51 +11,27 @@ module BELParser
         @semantics_functions = Semantics.semantics_functions
       end
 
-      def validate(term_ast)
-        results = syntax(term_ast)
+      def validate(expression_node)
+        results = syntax(expression_node)
         if results.empty?
-          results << Syntax::Valid.new(term_ast, @spec)
-          results.concat(semantics(term_ast))
+          results << Syntax::Valid.new(expression_node, @spec)
+          results.concat(semantics(expression_node))
         end
         results
       end
 
       private
 
-      def syntax(term_ast)
-        syntax_results = syntax_term(term_ast).compact
+      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(term_ast)
-        semantics_term(term_ast)
-      end
-
-      def syntax_term(term_ast)
-        syntax_results = @syntax_functions.flat_map do |syntax_func|
-          syntax_func.map(term_ast, @spec, @namespaces)
-        end
-
-        term_ast.arguments
-          .select(&:has_term?)
-          .map(&:child)
-          .each do |child_term|
-            syntax_results.concat(syntax_term(child_term))
-          end
-        syntax_results
-      end
-
-      def semantics_term(term_ast)
-        semantics_results = @semantics_functions.flat_map do |semantics_func|
-          semantics_func.map(term_ast, @spec, @namespaces)
-        end
-
-        term_ast.arguments
-          .select(&:has_term?)
-          .map(&:child)
-          .each do |child_term|
-            semantics_results.concat(semantics_term(child_term))
-          end
-        semantics_results
+      def semantics(expression_node)
+        expression_node.traverse.flat_map do |node|
+          @semantics_functions.map { |func| func.map(node, @spec, @namespaces) }
+        end.compact
       end
     end
   end

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

@@ -11,25 +11,21 @@ module BELParser
         # Map {BELParser::Parsers::AST::Term term} to BEL signatures defined
         # by a {BELParser::Language::Specification}. The mapping includes both
         # successful and failed signature matches.
-        def self.map(term_ast, spec, namespaces)
-          unless term_ast.is_a?(BELParser::Parsers::AST::Term)
-            raise(
-              ArgumentError,
-              "term_ast: expected BELParser::Parsers::AST::Term")
-          end
+        def self.map(term_node, spec, namespaces)
+          return nil unless term_node.is_a?(BELParser::Parsers::AST::Term)
 
-          function_name = term_ast.function.identifier.string_literal
+          function_name = term_node.function.identifier.string_literal
           function      = spec.function(function_name.to_sym)
           match         = BELParser::Language::Semantics.method(:match)
 
           successes, failures = function.signatures
-            .map       { |sig| [sig, match.call(term_ast, sig.semantic_ast, spec)] }
+            .map       { |sig| [sig, match.call(term_node, sig.semantic_ast, spec)] }
             .partition { |(sig, results)| results.all?(&:success?) }
 
           if successes.empty?
-            SignatureMappingWarning.new(term_ast, spec, failures)
+            SignatureMappingWarning.new(term_node, spec, failures)
           else
-            SignatureMappingSuccess.new(term_ast, spec, successes, failures)
+            SignatureMappingSuccess.new(term_node, spec, successes, failures)
           end
         end
       end
@@ -38,8 +34,8 @@ module BELParser
         attr_reader :success_signatures
         attr_reader :failure_signatures
 
-        def initialize(expression_node, spec, successes, failures)
-          super(expression_node, spec)
+        def initialize(term_node, spec, successes, failures)
+          super(term_node, spec)
           @success_signatures = successes
           @failure_signatures  = failures
         end
@@ -58,8 +54,8 @@ module BELParser
       class SignatureMappingWarning < SemanticsWarning
         attr_reader :failure_signatures
 
-        def initialize(expression_node, spec, failure_signatures)
-          super(expression_node, spec)
+        def initialize(term_node, spec, failure_signatures)
+          super(term_node, spec)
           @failure_signatures = failure_signatures
         end
 

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

@@ -10,27 +10,28 @@ module BELParser
 
         private_class_method :new
 
-        def self.map(term_node, spec, namespaces)
-          function_name = term_node.function.identifier.string_literal
+        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(term_node, spec, function_name)
+            InvalidFunctionSyntaxError.new(func_node, spec, function_name)
           end
         end
       end
 
       # InvalidFunctionSyntaxError indicates a function name was invalid.
       class InvalidFunctionSyntaxError < SyntaxError
-        # Gets the function literal that was invalid according to a
-        # BEL specification.
-        attr_reader :function
+        # Gets the invalid function literal.
+        attr_reader :invalid_function
 
-        def initialize(term_node, spec, function)
-          super(term_node, spec)
-          @function = function
+        def initialize(function, spec, invalid_function)
+          super(function, spec)
+          @invalid_function = invalid_function
         end
 
         def msg
-          %Q{Invalid function "#{function}".}
+          %Q{Invalid function "#{invalid_function}".}
         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
+          %Q{Invalid relationship "#{relationship}".}
+        end
+      end
+    end
+  end
+end

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

@@ -10,22 +10,16 @@ module BELParser
 
         private_class_method :new
 
-        def self.map(term_node, spec, namespaces)
-          syntax_results = []
-          term_node.arguments
-            .select(&:has_parameter?)
-            .map(&:child)
-            .each do |child_parameter|
-              prefix_identifier = child_parameter.prefix.identifier
-              next if prefix_identifier.nil?
-
-              namespace_prefix = prefix_identifier.string_literal
-              unless namespaces[namespace_prefix]
-                syntax_results << UndefinedNamespaceError.new(
-                  term_node, spec, namespace_prefix, namespaces)
-              end
-            end
-          syntax_results
+        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
 
@@ -37,8 +31,8 @@ module BELParser
         # Gets the defined namespaces.
         attr_reader :defined_namespaces
 
-        def initialize(term_node, spec, invalid_prefix, defined_namespaces)
-          super(term_node, spec)
+        def initialize(prefix_node, spec, invalid_prefix, defined_namespaces)
+          super(prefix_node, spec)
           @invalid_prefix     = invalid_prefix
           @defined_namespaces = defined_namespaces.dup
         end

data/lib/bel_parser/language/version1_0/return_types/molecular_activity.rb

@@ -1,4 +1,4 @@
-require_relative 'molecular_activity'
+require_relative 'any'
 
 module BELParser
   module Language

data/lib/bel_parser/language/version2_0/functions/protein_abundance.rb

@@ -120,28 +120,18 @@ module BELParser
 
               AST = BELParser::Language::Semantics::Builder.build do
                 term(
-                function(
-                  identifier(
-                    function_of(ProteinAbundance))),
-                argument(
-                  parameter(
-                    prefix(
-                      identifier(
-                        has_namespace,
-                        namespace_of(:*))),
-                    value(
-                      value_type(
-                        has_encoding,
-                        encoding_of(:ProteinAbundance))))),
-                argument(
-                  term(
-                    function(
-                      identifier(
-                        return_type_of(BELParser::Language::Version2_0::ReturnTypes::Fusion))))))              
+                  function(
+                    identifier(
+                      function_of(ProteinAbundance))),
+                  argument(
+                    term(
+                      function(
+                        identifier(
+                          return_type_of(BELParser::Language::Version2_0::ReturnTypes::Fusion))))))
               end
               private_constant :AST
 
-              STRING_FORM = 'proteinAbundance(E:proteinAbundance,F:fusion)proteinAbundance'.freeze
+              STRING_FORM = 'proteinAbundance(F:fusion)proteinAbundance'.freeze
               private_constant :STRING_FORM
 
               def self.semantic_ast

data/lib/bel_parser/parser.rb

@@ -22,7 +22,7 @@ module BELParser
       :term,
       :relationship,
       :observed_term,
-      :statement_simple,
+      :simple_statement,
       :nested_statement,
       :define_annotation,
       :define_namespace,

data/lib/bel_parser/parsers/ast/node.rb

@@ -377,6 +377,11 @@ module BELParser
         def initialize(children = [], properties = {})
           super(Relationship.ast_type, children, properties)
         end
+
+        # Get the string literal.
+        def string_literal
+          children[0]
+        end
       end
 
       # AST node representing a set.
@@ -420,7 +425,33 @@ module BELParser
 
         # Get the subject of the statement.
         def subject
-          # TODO: access children for content
+          children[0]
+        end
+
+        def has_relationship?
+          children[1] && children[1].is_a?(Relationship)
+        end
+
+        # Get the relationship of the nested statement.
+        def relationship
+          has_relationship? ? children[1] : nil
+        end
+
+        def has_object?
+          children[2] && children[2].is_a?(Object)
+        end
+
+        # Get the object of the nested statement.
+        def object
+          has_object? ? children[2] : nil
+        end
+
+        def has_comment?
+          children[-1] && children[-1].is_a?(Comment)
+        end
+
+        def comment
+          has_comment? ? children[-1] : nil
         end
       end
 
@@ -438,14 +469,19 @@ module BELParser
           super(NestedStatement.ast_type, children, properties)
         end
 
+        # Get the subject of the statement.
+        def subject
+          children[0]
+        end
+
         # Get the relationship of the nested statement.
-        def relatitonship
-          # TODO: access children for content
+        def relationship
+          children[1]
         end
 
         # Get the object of the nested statement.
         def object
-          # TODO: access children for content
+          children[2]
         end
       end
 
@@ -462,6 +498,11 @@ module BELParser
         def initialize(children = [], properties = {})
           super(ObservedTerm.ast_type, children, properties)
         end
+
+        # Get the subject of the statement.
+        def subject
+          children[0]
+        end
       end
 
       # AST node representing a simple statement.
@@ -478,14 +519,19 @@ module BELParser
           super(SimpleStatement.ast_type, children, properties)
         end
 
+        # Get the subject of the statement.
+        def subject
+          children[0]
+        end
+
         # Get the relationship of the nested statement.
-        def relatitonship
-          # TODO: access children for content
+        def relationship
+          children[1]
         end
 
         # Get the object of the nested statement.
         def object
-          # TODO: access children for content
+          children[2]
         end
       end