bel_parser 1.0.0.alpha.3 → 1.0.0.alpha.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fc1ced9daf61e6924edb4e15fe137e76fac85049
-  data.tar.gz: 1662c4c080eb06306ddc52a0c730bb226fe89e69
+  metadata.gz: 3ef8ebaf115a02e0b19b7af93039277e7e31ec98
+  data.tar.gz: 9a34c875fa35ea3926b2c285b7ea031320e39194
 SHA512:
-  metadata.gz: 614db5a804a2ded6d9df1e93fe0a656fc033deccce4a20b649a52ead92eb18efc89900cbb3946f48faa97f29c0657b4c2190e7a987db0fc86b8c8ed9864356ee
-  data.tar.gz: 1d10d5b3a5605cd52ed3adde6998a0f6d0412c4f5008b71f818398e7f80e173348ac849f82b333c89ead3b1015fd75db5aff08fdf395f59198e60aabc43648a0
+  metadata.gz: 2c355a19969807bc4d582a62a66f84cdac544efbd2a2a117d18c53c21dcb2dd0ae9043ce18d801f6475e0e40af1d2886518c3249ec77b3951d8e4b178586ed07
+  data.tar.gz: 0c7e304b87dea0e1b27009d93190a1f862f04e8cc4283f482e3117b55441467f160da8e0925bc05d3b7c4a12119cf6ec71786c2d11084c5a58f4e8bb1147a550

data/VERSION

@@ -1 +1 @@
-1.0.0.alpha.3
+1.0.0.alpha.4

data/bin/bel2_validator

@@ -13,7 +13,5 @@ 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|
-  res.each do |res|
-    puts "  #{res}"
-  end
+  puts res.map { |r| "#{r}\n" }.join.each_line.map { |l| "  #{l}" }.join
 end

data/lib/bel_parser/expression/term_validator.rb

@@ -44,7 +44,7 @@ if __FILE__ == $PROGRAM_NAME
   namespaces = Hash[ARGV[1..-1].map { |ns| ns.split('=') }]
   BELParser::Expression::TermValidator.new(ARGV.first, namespaces).each($stdin) do |res|
     res.each do |res|
-      puts "  #{res}"
+      puts res.each_line.map { |l| "  #{l}" }.join
     end
   end
 end

data/lib/bel_parser/language/expression_validator.rb

@@ -5,27 +5,57 @@ module BELParser
   module Language
     class ExpressionValidator
       def initialize(spec, namespaces)
-        @spec             = spec
-        @namespaces       = namespaces
-        @syntax_functions = Syntax.syntax_functions
+        @spec                = spec
+        @namespaces          = namespaces
+        @syntax_functions    = Syntax.syntax_functions
+        @semantics_functions = Semantics.semantics_functions
       end
 
-      def validate(expression_ast)
-        syntax_problems = syntax(expression_ast)
-        return syntax_problems unless syntax_problems.empty?
-        [Syntax::Valid.new(expression_ast, @spec)] + semantics(expression_ast)
+      def validate(term_ast)
+        results = syntax(term_ast)
+        if results.empty?
+          results << Syntax::Valid.new(term_ast, @spec)
+          results.concat(semantics(term_ast))
+        end
+        results
       end
 
       private
 
-      def syntax(expression_ast)
-        @syntax_functions.flat_map do |syntax_function|
-          syntax_function.map(expression_ast, @spec, @namespaces)
+      def syntax(term_ast)
+        syntax_results = syntax_term(term_ast).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(expression_ast)
-        BELParser::Language::Semantics.check_term(expression_ast, @spec)
+      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
       end
     end
   end

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

@@ -0,0 +1,78 @@
+require 'bel_parser/parsers/ast/node'
+
+module BELParser
+  module Language
+    module Semantics
+      class SignatureMapping
+        include SemanticsFunction
+
+        private_class_method :new
+
+        # 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
+
+          function_name = term_ast.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)] }
+            .partition { |(sig, results)| results.all?(&:success?) }
+
+          if successes.empty?
+            SignatureMappingWarning.new(term_ast, spec, failures)
+          else
+            SignatureMappingSuccess.new(term_ast, spec, successes, failures)
+          end
+        end
+      end
+
+      class SignatureMappingSuccess < SemanticsResult
+        attr_reader :success_signatures
+        attr_reader :failure_signatures
+
+        def initialize(expression_node, spec, successes, failures)
+          super(expression_node, spec)
+          @success_signatures = successes
+          @failure_signatures  = failures
+        end
+
+        def to_s
+          sig_list = success_signatures
+            .map { |(sig, results)| sig.string_form }
+            .join("\n  ")
+          <<-MSG.gsub(/ {12}/, '').gsub(/\n$/, '')
+            Term matches function signatures:
+              #{sig_list}
+          MSG
+        end
+      end
+
+      class SignatureMappingWarning < SemanticsWarning
+        attr_reader :failure_signatures
+
+        def initialize(expression_node, spec, failure_signatures)
+          super(expression_node, spec)
+          @failure_signatures = failure_signatures
+        end
+
+        def to_s
+          sig_list = failure_signatures
+            .map { |(sig, results)| sig.string_form }
+            .join("\n  ")
+          <<-MSG.gsub(/ {12}/, '').gsub(/\n$/, '')
+            Term did not conform to function signatures:
+              #{sig_list}
+          MSG
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/language/semantics.rb

@@ -1,2 +1,35 @@
-require_relative 'semantics/semantic_ast'
-require_relative 'semantics/analyzer'
+require_relative 'semantics_match'
+require_relative 'semantics_ast'
+require_relative 'semantics_result'
+require_relative 'semantics_warning'
+require_relative 'semantics_function'
+
+module BELParser
+  module Language
+    module Semantics
+      def self.semantics_functions
+        self.constants.collect do |symbol|
+          const = self.const_get(symbol)
+          const if
+            const.respond_to?(:include?) &&
+            const.include?(SemanticsFunction)
+        end.compact
+      end
+
+      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/semantic_ast.rb → semantics_ast.rb}

@@ -1,6 +1,6 @@
-require_relative 'semantic_match'
-require_relative '../quoting'
-require_relative '../../parsers/ast/node'
+require_relative 'semantics_match'
+require_relative 'quoting'
+require_relative '../parsers/ast/node'
 
 module BELParser
   module Language

data/lib/bel_parser/language/semantics_function.rb

@@ -0,0 +1,13 @@
+module BELParser
+  module Language
+    module Semantics
+      module SemanticsFunction
+        # @abstract Include {SemanticsFunction} and override {#map} to check
+        # term semantics (e.g. signatures).
+        def self.map(term_ast, spec, namespaces)
+          raise NotImplementedError, "#{__method__} is not implemented."
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/language/semantics_result.rb

@@ -0,0 +1,23 @@
+module BELParser
+  module Language
+    module Semantics
+      class SemanticsResult
+        attr_reader :expression_node, :specification
+
+        def initialize(expression_node, specification)
+          @expression_node = expression_node
+          @specification   = specification
+        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/semantics_warning.rb

@@ -0,0 +1,17 @@
+require_relative 'semantics_result'
+
+module BELParser
+  module Language
+    module Semantics
+      class SemanticsWarning < SemanticsResult
+        def initialize(expression_node, specification)
+          super(expression_node, specification)
+        end
+
+        def to_s
+          "Warning: #{msg}"
+        end
+      end
+    end
+  end
+end

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

@@ -10,33 +10,27 @@ module BELParser
 
         private_class_method :new
 
-        def self.map(expression_ast, spec, namespaces)
-          errors = []
-          expression_ast.traverse.map do |node|
-            next unless node.is_a?(BELParser::Parsers::AST::Function)
-            function_name = node.identifier.string_literal
-            unless spec.function(function_name.to_sym)
-              errors << InvalidFunctionSyntaxError.new(
-                expression_ast, spec, node, spec.functions)
-            end
+        def self.map(term_node, spec, namespaces)
+          function_name = term_node.function.identifier.string_literal
+          unless spec.function(function_name.to_sym)
+            InvalidFunctionSyntaxError.new(term_node, spec, function_name)
           end
-          errors
         end
       end
 
       # InvalidFunctionSyntaxError indicates a function name was invalid.
       class InvalidFunctionSyntaxError < SyntaxError
-        # Gets the functions defined by a BEL specification.
-        attr_reader :bel_functions
+        # Gets the function literal that was invalid according to a
+        # BEL specification.
+        attr_reader :function
 
-        def initialize(expression_node, spec, error_node, bel_functions)
-          super(expression_node, spec, error_node)
-          @bel_functions = bel_functions
+        def initialize(term_node, spec, function)
+          super(term_node, spec)
+          @function = function
         end
 
         def msg
-          invalid_function = error_node.identifier.string_literal
-          %Q{Invalid function "#{invalid_function}".}
+          %Q{Invalid function "#{function}".}
         end
       end
     end

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

@@ -10,36 +10,43 @@ module BELParser
 
         private_class_method :new
 
-        def self.map(expression_ast, spec, namespaces)
-          errors = []
-          expression_ast.traverse.map do |node|
-            next unless node.is_a?(BELParser::Parsers::AST::Prefix)
-            next if node.identifier.nil?
-
-            namespace_prefix = node.identifier.string_literal
-            unless namespaces[namespace_prefix]
-              errors << UndefinedNamespaceError.new(
-                expression_ast, node, namespaces)
+        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, node, namespaces)
+              end
             end
-          end
-          errors
+          syntax_results
         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(expression_node, spec, error_node, defined_namespaces)
-          super(expression_node, spec, error_node)
+        def initialize(term_node, spec, invalid_prefix, defined_namespaces)
+          super(term_node, spec, error_node)
+          @invalid_prefix     = invalid_prefix
           @defined_namespaces = defined_namespaces.dup
         end
 
         def msg
-          undefined_namespace = error_node.identifier.string_literal
-          %Q{Undefined namespace "#{undefined_namespace}".}
+          <<-MSG.gsub(/ {10}/, '')
+            Undefined namespace "#{invalid_prefix}".
+            Defined namespaces are: #{defined_namespaces.keys.join(', ')}
+          MSG
         end
       end
     end

data/lib/bel_parser/language/syntax_error.rb

@@ -4,11 +4,8 @@ module BELParser
   module Language
     module Syntax
       class SyntaxError < SyntaxResult
-        attr_reader :expression_node, :target_node
-
-        def initialize(expression_node, specification, target_node)
+        def initialize(expression_node, specification)
           super(expression_node, specification)
-          @target_node = target_node
         end
 
         # @abstract Subclass and override {#msg} to provide the message.

data/lib/bel_parser/language/syntax_warning.rb

@@ -4,7 +4,7 @@ module BELParser
   module Language
     module Syntax
       class SyntaxWarning < SyntaxResult
-        attr_reader :expression_node, :target_node
+        attr_reader :target_node
 
         def initialize(expression_node, specification, target_node)
           super(expression_node, specification)

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

@@ -352,6 +352,16 @@ module BELParser
         def initialize(children = [], properties = {})
           super(Parameter.ast_type, children, properties)
         end
+
+        # Get the prefix for the parameter.
+        def prefix
+          children[0]
+        end
+
+        # Get the value for the parameter.
+        def value
+          children[1]
+        end
       end
 
       # AST node representing a relationship.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bel_parser
 version: !ruby/object:Gem::Version
-  version: 1.0.0.alpha.3
+  version: 1.0.0.alpha.4
 platform: ruby
 authors:
 - Anthony Bargnesi
@@ -36,9 +36,12 @@ files:
 - lib/bel_parser/language/quoting.rb
 - lib/bel_parser/language/relationship.rb
 - lib/bel_parser/language/semantics.rb
-- lib/bel_parser/language/semantics/analyzer.rb
-- lib/bel_parser/language/semantics/semantic_ast.rb
-- lib/bel_parser/language/semantics/semantic_match.rb
+- lib/bel_parser/language/semantics/signature_mapping.rb
+- lib/bel_parser/language/semantics_ast.rb
+- lib/bel_parser/language/semantics_function.rb
+- lib/bel_parser/language/semantics_match.rb
+- lib/bel_parser/language/semantics_result.rb
+- lib/bel_parser/language/semantics_warning.rb
 - lib/bel_parser/language/signature.rb
 - lib/bel_parser/language/specification.rb
 - lib/bel_parser/language/syntax.rb

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

@@ -1,59 +0,0 @@
-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