bel_parser 1.1.3-java → 1.1.4-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dbb2c6873145830a18fedf1164da4505ab32c4cd
-  data.tar.gz: 16e51a23649115539f81f6391c4eca8ad3b5d06e
+  metadata.gz: 1c91d5cda71bc86120353f6c6c30469ebf03bdb6
+  data.tar.gz: c7bf26f80357b8ad94e74157bfb91cd5385bff38
 SHA512:
-  metadata.gz: 650f98be712db578f9b0376e606fcefb9ed0e8e9c015cac5d0e2e43d4c8636782c8928aa9b2baba47c6ad1a61b91b58d69ce84d6202ede98d6611af8291d1dbc
-  data.tar.gz: 3f76b83bd32877aef24f380b5aeb0bb62ac08d7aea5fe4255d27dfe9811068395a383a3857d537fb1ef05f660349faf81ace7acd40937127f34fb4982ad618a1
+  metadata.gz: 90594c6de5c640c2713ca6ca1b70b059ce81ccb4bec97188f074ce4608fda969a3ddbd7c5e4b43e30ab74cb76d4da5bf99e84637fa9b2076351f2c6e394c5d8b
+  data.tar.gz: e7181dd3b0fbbfa3639235e045b364916f758eff5e811521c2af6106af3cad73febed97bd11d7e608e17f9a1df869cd31f64a0c9bca01b6db48355ecb94492d8

data/README.md

@@ -61,7 +61,7 @@ To make a release, perform the following steps:
 
   Ruby: `gem build .gemspec`
 
-  Java: `gem build .gemspec-java`
+  Java: `jruby -S gem build .gemspec`
 
 - Create a release on GitHub with both gems and a summary of the changes in this version.
 

data/VERSION

@@ -1 +1 @@
-1.1.3
+1.1.4

data/bin/bel2_completion

@@ -0,0 +1,127 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(
+  File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib'))
+
+require 'optparse'
+require 'bel_parser'
+require 'bel_parser/parsers/expression/statement_autocomplete'
+require 'bel_parser/expression/validator'
+require 'bel_parser/resource/resource_url_reader'
+
+options = {
+  uri_reader: BELParser::Resource.default_uri_reader,
+  url_reader: BELParser::Resource.default_url_reader,
+  spec: BELParser::Language.specification(
+    BELParser::Language.latest_supported_version),
+  will_match_partial: false
+}
+OptionParser.new do |opts|
+  opts.banner = <<-USAGE.gsub(/^ {4}/, '')
+    Provides completions for BEL expressions.
+
+    Read from standard input.
+    usage: #$PROGRAM_NAME
+  USAGE
+
+  opts.on(
+    '-v',
+    '--[no-]verbose',
+    'Enable verbose logging.') do |verbose|
+      options[:verbose] = verbose
+    end
+
+  opts.on(
+    '-s',
+    '--specification VERSION',
+    'BEL specification version (e.g. 1.0, 2.0).') do |spec|
+      unless BELParser::Language.defines_version?(spec)
+        $stderr.puts %(Invalid BEL specification "#{spec}")
+        exit 1
+      end
+
+      options[:spec] = BELParser::Language.specification(spec)
+    end
+
+  opts.on(
+    '-p',
+    '--[no-]match-partial',
+    'Partial semantic matches are allowed.') do |will_match_partial|
+      options[:will_match_partial] = will_match_partial
+    end
+
+  if RUBY_ENGINE =~ /^jruby/i
+    opts.on(
+      '-t',
+      '--read-jena-tdb DIRECTORY',
+      'Jena TDB directory containing BEL RDF resources.') do |tdb|
+
+        require 'bel_parser/resource/jena_tdb_reader'
+        options[:uri_reader] = BELParser::Resource::JenaTDBReader.new(tdb)
+        BELParser::Resource.default_uri_reader = options[:uri_reader]
+      end
+  end
+end.parse!
+
+io = $stdin
+
+class ::AST::Node
+
+  def _metadata
+    ivars = instance_variables - [:@type, :@children, :@hash]
+    ivars.map { |iv| [iv, instance_variable_get(iv)] }.to_s
+  end
+  private :_metadata
+
+  def to_sexp(indent=0)
+    indented = "  " * indent
+    sexp = "#{indented}(#{fancy_type} #{_metadata}"
+
+    first_node_child = children.index do |child|
+      child.is_a?(::AST::Node) || child.is_a?(Array)
+    end || children.count
+
+    children.each_with_index do |child, idx|
+      if child.is_a?(::AST::Node) && idx >= first_node_child
+        sexp << "\n#{child.to_sexp(indent + 1)}"
+      else
+        sexp << " #{child.inspect}"
+      end
+    end
+
+    sexp << ")"
+
+    sexp
+  end
+end
+
+#uri_reader, url_reader = options.values_at(:uri_reader, :url_reader)
+
+namespaces = Hash[
+  ARGV.map do |ns|
+    keyword, identifier = ns.split('=')
+    if identifier.end_with?('.belns')
+      [keyword, BELParser::Expression::Model::Namespace.new(keyword, nil, identifier)]
+    else
+      [keyword, BELParser::Expression::Model::Namespace.new(keyword, identifier, nil)]
+    end
+  end.compact
+]
+
+autocomplete = BELParser::Parsers::Expression::StatementAutocomplete
+validator    = BELParser::Language::ExpressionValidator.new(
+  BELParser::Language.specification('2.0'),
+  namespaces,
+  BELParser::Resource.default_uri_reader,
+  BELParser::Resource.default_url_reader,
+  options[:will_match_partial]
+)
+
+io.each_line do |line|
+  line.strip!
+  ast, _ = autocomplete.parse("#{line}\n", line.length)
+  puts "AST:\n#{ast.to_sexp(1)}"
+  term_result = validator.validate(ast.subject.term)
+  puts "     Syntax: #{term_result.valid_syntax?}"
+  puts "  Semantics: #{term_result.valid_semantics?}"
+  puts term_result
+end

data/lib/bel_parser/completion.rb

@@ -11,7 +11,8 @@ module BELParser
     extend BELParser::Parsers::AST::Sexp
     extend BELParser::Parsers
 
-    def self.complete(input, spec, search, namespaces, caret_position = input.length)
+    def self.complete(input, spec, search, namespaces,
+                      caret_position = input.length, include_invalid_semantics = false)
       # Algorithm
       # 1. Parse AST using statement_autocomplete ragel FSM.
       # 2. Given cursor find node to complete.
@@ -39,77 +40,100 @@ module BELParser
           []
         end
 
-      urir      = BELParser::Resource.default_uri_reader
-      urlr      = BELParser::Resource.default_url_reader
-      validator = BELParser::Language::ExpressionValidator.new(spec, namespaces, urir, urlr)
+      will_match_partial = true
+      urir               = BELParser::Resource.default_uri_reader
+      urlr               = BELParser::Resource.default_url_reader
+
+      validator =
+        BELParser::Language::ExpressionValidator.new(
+          spec, namespaces, urir, urlr, will_match_partial
+        )
 
       validated_completions =
         completions
           .map { |(completion_ast, completion_result)|
-            message             = ''
-            terms               = completion_ast.traverse.select { |node| node.type == :term }.to_a
-            semantics_functions =
-              BELParser::Language::Semantics.semantics_functions.reject { |fun|
-                fun == BELParser::Language::Semantics::SignatureMapping
-              }
-
-            semantic_warnings =
-              completion_ast
-                .traverse
-                .flat_map { |node|
-                  semantics_functions.flat_map { |func|
-                    func.map(node, spec, namespaces)
-                  }
-                }
-                .compact
 
-            if semantic_warnings.empty?
-              valid = true
+            if completion_result[:type] == :namespace_prefix
+              # namespace_prefix completions are always valid
+              completion_result[:validation] = {
+                expression:      completion_result[:value],
+                valid_syntax:    true,
+                valid_semantics: true,
+                message:         'Valid semantics',
+                warnings:        [],
+                term_signatures: []
+              }
+              completion_result
             else
-              valid = false
-              message =
-                semantic_warnings.reduce('') { |msg, warning|
-                  msg << "#{warning}\n"
+              message             = ''
+              terms               = completion_ast.traverse.select { |node| node.type == :term }.to_a
+              semantics_functions =
+                BELParser::Language::Semantics.semantics_functions.reject { |fun|
+                  fun == BELParser::Language::Semantics::SignatureMapping
                 }
-              message << "\n"
-            end
 
-            term_semantics =
-              terms.map { |term|
-                term_result = validator.validate(term)
-                valid      &= term_result.valid_semantics?
-                bel_term    = serialize(term)
+              semantic_warnings =
+                completion_ast
+                  .traverse
+                  .flat_map { |node|
+                    semantics_functions.flat_map { |func|
+                      func.map(node, spec, namespaces, will_match_partial)
+                    }
+                  }
+                  .compact
 
-                unless valid
-                  message << "Term: #{bel_term}\n"
-                  term_result.invalid_signature_mappings.map { |m|
-                    message << "  #{m}\n"
+              if semantic_warnings.empty?
+                valid = true
+              else
+                valid = false
+                message =
+                  semantic_warnings.reduce('') { |msg, warning|
+                    msg << "#{warning}\n"
                   }
-                  message << "\n"
-                end
+                message << "\n"
+              end
 
-                {
-                  term:               bel_term,
-                  valid_signatures:   term_result.valid_signature_mappings.map(&:to_s),
-                  invalid_signatures: term_result.invalid_signature_mappings.map(&:to_s)
+              term_semantics =
+                terms.map { |term|
+                  term_result = validator.validate(term)
+                  valid      &= term_result.valid_semantics?
+                  bel_term    = serialize(term)
+
+                  unless valid
+                    message << "Term: #{bel_term}\n"
+                    term_result.invalid_signature_mappings.map { |m|
+                      message << "  #{m}\n"
+                    }
+                    message << "\n"
+                  end
+
+                  {
+                    term:               bel_term,
+                    valid_signatures:   term_result.valid_signature_mappings.map(&:to_s),
+                    invalid_signatures: term_result.invalid_signature_mappings.map(&:to_s)
+                  }
                 }
-              }
 
-            completion_result[:validation] = {
-              expression:      completion_result[:value],
-              valid_syntax:    true,
-              valid_semantics: valid,
-              message:         valid ? 'Valid semantics' : message,
-              warnings:        semantic_warnings.map(&:to_s),
-              term_signatures: term_semantics
-            }
-            completion_result
+              completion_result[:validation] = {
+                expression:      completion_result[:value],
+                valid_syntax:    true,
+                valid_semantics: valid,
+                message:         valid ? 'Valid semantics' : message,
+                warnings:        semantic_warnings.map(&:to_s),
+                term_signatures: term_semantics
+              }
+              completion_result
+            end
           }
           .group_by { |completion_result|
             completion_result[:validation][:valid_semantics]
           }
 
-      (validated_completions[true] || []) + (validated_completions[false] || [])
+      if include_invalid_semantics
+        (validated_completions[true] || []) + (validated_completions[false] || [])
+      else
+        validated_completions[true] || []
+      end
     end
 
     def self.complete_function(

data/lib/bel_parser/language/expression_validator.rb

@@ -9,15 +9,20 @@ module BELParser
     # when supplied a {BELParser::Language::Specification} and Hash of
     # namespaces.
     class ExpressionValidator
-      def initialize(spec, namespaces, uri_reader, url_reader)
+      def initialize(spec, namespaces, uri_reader, url_reader, will_match_partial = false)
         @spec                         = spec
         @namespaces                   = namespaces || {}
+
+        # double negate truthy or falsey value to strict boolean
+        @will_match_partial           = !!will_match_partial
+
         @syntax_functions             = Syntax.syntax_functions
         @semantics_functions          = Semantics.semantics_functions
         @default_namespace_transform  =
           ApplyDefaultNamespace.new(@spec, @namespaces, uri_reader, url_reader)
         @namespace_encoding_transform =
           ApplyNamespaceEncoding.new(@spec, @namespaces, uri_reader, url_reader)
+
       end
 
       # Validate the syntax and semantics of
@@ -85,7 +90,9 @@ module BELParser
 
       def semantics(expression_node)
         expression_node.traverse.flat_map do |node|
-          @semantics_functions.flat_map { |func| func.map(node, @spec, @namespaces) }
+          @semantics_functions.flat_map { |func|
+            func.map(node, @spec, @namespaces, @will_match_partial)
+          }
         end.compact
       end
 

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

@@ -18,7 +18,7 @@ module BELParser
 
         private_class_method :new
 
-        def self.map(node, spec, _namespaces)
+        def self.map(node, spec, _namespaces, will_match_partial = false)
           return nil unless node.is_a?(BELParser::Parsers::AST::NestedStatement)
 
           nested_number = count_nested_statements(node)

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

@@ -12,7 +12,7 @@ module BELParser
 
         private_class_method :new
 
-        def self.map(node, spec, _namespaces)
+        def self.map(node, spec, _namespaces, will_match_partial = false)
           return nil unless node.is_a?(BELParser::Parsers::AST::Function)
           return nil unless node.identifier
 

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

@@ -13,7 +13,7 @@ module BELParser
 
         private_class_method :new
 
-        def self.map(node, spec, _namespaces)
+        def self.map(node, spec, _namespaces, will_match_partial = false)
           return nil unless node.is_a?(BELParser::Parsers::AST::Subject)
 
           list_func = spec.function(:list)

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

@@ -11,7 +11,7 @@ module BELParser
 
         private_class_method :new
 
-        def self.map(stmt_node, spec, _namespaces)
+        def self.map(stmt_node, spec, _namespaces, will_match_partial = false)
           return nil unless stmt_node.is_a?(BELParser::Parsers::AST::Statement)
           return nil unless stmt_node.relationship?
           return nil if stmt_node.relationship.string_literal.nil?

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

@@ -11,7 +11,7 @@ module BELParser
 
         private_class_method :new
 
-        def self.map(node, spec, _namespaces)
+        def self.map(node, spec, _namespacesi, will_match_partial = false)
           return nil unless node.is_a?(BELParser::Parsers::AST::Statement)
           return nil unless node.object? && node.object.statement?
 

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

@@ -11,7 +11,7 @@ module BELParser
 
         private_class_method :new
 
-        def self.map(node, spec, _namespaces)
+        def self.map(node, spec, _namespaces, will_match_partial = false)
           return nil unless node.is_a?(BELParser::Parsers::AST::Statement)
           return nil unless node.object? && node.object.statement?
 

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

@@ -11,7 +11,7 @@ module BELParser
 
         private_class_method :new
 
-        def self.map(stmt_node, spec, _namespaces)
+        def self.map(stmt_node, spec, _namespaces, will_match_partial = false)
           return nil unless stmt_node.is_a?(BELParser::Parsers::AST::Statement)
           return nil unless stmt_node.relationship?
           return nil unless stmt_node.object?

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

@@ -12,7 +12,7 @@ module BELParser
 
         private_class_method :new
 
-        def self.map(node, spec, _namespaces)
+        def self.map(node, spec, _namespaces, will_match_partial = false)
           return nil unless node.is_a?(BELParser::Parsers::AST::Relationship)
           return nil if node.string_literal.nil?
 

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

@@ -11,7 +11,7 @@ module BELParser
 
         private_class_method :new
 
-        def self.map(node, spec, _namespaces)
+        def self.map(node, spec, _namespaces, will_match_partial = false)
           return nil unless node.is_a?(BELParser::Parsers::AST::Statement)
           return nil unless node.relationship?
           return nil unless node.object?

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

@@ -17,30 +17,48 @@ 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_node, spec, _namespaces)
+        def self.map(term_node, spec, _namespaces, will_match_partial = false)
           return nil unless term_node.is_a?(BELParser::Parsers::AST::Term)
           return nil unless term_node.function
           return nil unless term_node.function.identifier
 
+          # double negate truthy or falsey value to strict boolean
+          will_match_partial = !!will_match_partial
+
           function_name = term_node.function.identifier.string_literal
           function      = spec.function(function_name.to_sym)
           return nil unless function
 
-          mapsig = method(:map_signature).to_proc.curry[term_node][spec]
-          function.signatures.map(&mapsig)
+          function.signatures.map { |signature|
+            self._map_signature(term_node, spec, signature, will_match_partial)
+          }
         end
 
-        def self.map_signature(term_node, spec, signature)
-          results = BELParser::Language::Semantics.match(
-            term_node,
-            signature.semantic_ast,
-            spec)
+        private
+
+        def self._map_signature(term_node, spec, signature, will_match_partial)
+          results =
+            BELParser::Language::Semantics.match(
+              term_node,
+              signature.semantic_ast,
+              spec,
+              will_match_partial
+            )
+
+          _remove_partial_warnings!(results) if will_match_partial
+
           if results.all?(&:success?)
             SignatureMappingSuccess.new(term_node, spec, signature, results)
           else
             SignatureMappingWarning.new(term_node, spec, signature, results)
           end
         end
+
+        def self._remove_partial_warnings!(semantic_results)
+          semantic_results.reject! { |res|
+            res.is_a?(SemanticsNilNodeWarning)
+          }
+        end
       end
 
       # SignatureMappingSuccess defines a {SemanticsResult} that indicates

data/lib/bel_parser/language/semantics_ast.rb

@@ -10,8 +10,8 @@ module BELParser
     module Semantics
       # rubocop:disable Metrics/MethodLength
       # rubocop:disable Metrics/AbcSize
-      def self.match(input_ast, semantic_ast, spec, match_results = [])
-        res = semantic_ast.match(input_ast, spec)
+      def self.match(input_ast, semantic_ast, spec, will_match_partial = false, match_results = [])
+        res = semantic_ast.match(input_ast, spec, will_match_partial)
         match_results.concat(res)
         if res.flatten.all?(&:success?) && !semantic_ast.terminal?
           return match_results if semantic_ast.children.empty?
@@ -35,24 +35,26 @@ module BELParser
                   input_children[input_children.index(input_child)..-1]
                 argument_pattern = semantic_child.children.first
                 input_arguments.each do |argument_child|
-                  res = semantic_child.match(argument_child, spec)
+                  res = semantic_child.match(argument_child, spec, will_match_partial)
                   match_results << res
                   if res.all?(&:success?)
                     param_or_term = argument_child.children.first
-                    match(param_or_term, argument_pattern, spec, match_results)
+                    match(param_or_term, argument_pattern, spec, will_match_partial, match_results)
                   end
                 end
               else
-                match(input_child, semantic_child, spec, match_results)
+                match(input_child, semantic_child, spec, will_match_partial, match_results)
               end
             end
           else
-            semantic_ast
-              .children
-              .zip(input_ast.children)
-              .each do |semantic_child, input_child|
-                match(input_child, semantic_child, spec, match_results)
-              end
+            if input_ast
+              semantic_ast
+                .children
+                .zip(input_ast.children)
+                .each do |semantic_child, input_child|
+                  match(input_child, semantic_child, spec, will_match_partial, match_results)
+                end
+            end
           end
         end
         match_results.flatten
@@ -268,7 +270,7 @@ module BELParser
           children[1..-1]
         end
 
-        def match(parse_node, spec)
+        def match(parse_node, spec, will_match_partial = false)
           return nil_node_warning(
             parse_node,
             spec,
@@ -279,12 +281,16 @@ module BELParser
             BELParser::Parsers::AST::Term,
             parse_node) if parse_node.type != type
 
-          # Return success if semantic AST does not supply argument patterns.
+          # Allowed empty.
           if arguments.empty? || variadic_arguments?
             success(parse_node, spec)
-          # Or, check argument length.
+          # Partial match on arity.
+          elsif will_match_partial && parse_node.arguments.length < arguments.length
+            success(parse_node, spec)
+          # Or, check full arity
           elsif arguments.length == parse_node.arguments.length
             success(parse_node, spec)
+          # Mismatch, warning
           else
             argument_length_warning(
               parse_node,
@@ -301,7 +307,7 @@ module BELParser
           super(:statement, children, properties)
         end
 
-        def match(parse_node, spec)
+        def match(parse_node, spec, will_match_partial = false)
           return nil_node_warning(
             parse_node,
             spec,
@@ -325,7 +331,7 @@ module BELParser
           super(:parameter, children, properties)
         end
 
-        def match(parse_node, spec)
+        def match(parse_node, spec, will_match_partial = false)
           return nil_node_warning(
             parse_node,
             spec,
@@ -349,7 +355,7 @@ module BELParser
           super(:function, children, properties)
         end
 
-        def match(parse_node, spec)
+        def match(parse_node, spec, will_match_partial = false)
           return nil_node_warning(
             parse_node,
             spec,
@@ -373,7 +379,7 @@ module BELParser
           super(:argument, children, properties)
         end
 
-        def match(parse_node, spec)
+        def match(parse_node, spec, will_match_partial = false)
           return nil_node_warning(
             parse_node,
             spec,
@@ -397,7 +403,7 @@ module BELParser
           super(:variadic_arguments, children, properties)
         end
 
-        def match(parse_node, spec)
+        def match(parse_node, spec, will_match_partial = false)
           return nil_node_warning(
             parse_node,
             spec,
@@ -429,7 +435,7 @@ module BELParser
           children
         end
 
-        def match(parse_node, spec)
+        def match(parse_node, spec, will_match_partial = false)
           return nil_node_warning(
             parse_node,
             spec,
@@ -463,7 +469,7 @@ module BELParser
           children
         end
 
-        def match(parse_node, spec)
+        def match(parse_node, spec, will_match_partial = false)
           return nil_node_warning(
             parse_node,
             spec,
@@ -493,7 +499,7 @@ module BELParser
           true
         end
 
-        def match(parse_node, spec)
+        def match(parse_node, spec, will_match_partial = false)
           if parse_node.nil?
             success(parse_node, spec)
           else
@@ -516,7 +522,7 @@ module BELParser
           children
         end
 
-        def match(identifier, spec)
+        def match(identifier, spec, will_match_partial = false)
           return nil_node_warning(
             identifier,
             spec,
@@ -540,7 +546,7 @@ module BELParser
           super(:any, [], properties)
         end
 
-        def match(parse_node, spec)
+        def match(parse_node, spec, will_match_partial = false)
           success(parse_node, spec)
         end
       end
@@ -551,7 +557,7 @@ module BELParser
           super(:has_namespace, [], properties)
         end
 
-        def match(prefix, spec)
+        def match(prefix, spec, will_match_partial = false)
           if prefix.respond_to?(:namespace) && prefix.namespace
             success(prefix, spec)
           else
@@ -570,7 +576,7 @@ module BELParser
           children
         end
 
-        def match(prefix_node, spec)
+        def match(prefix_node, spec, will_match_partial = false)
           unless prefix_node.respond_to?(:namespace) && prefix_node.namespace
             return invalid_namespace(prefix_node, spec, namespaces)
           end
@@ -589,7 +595,7 @@ module BELParser
           super(:has_encoding, [], properties)
         end
 
-        def match(value_node, spec)
+        def match(value_node, spec, will_match_partial = false)
           if value_node.respond_to?(:encoding) && value_node.encoding
             success(value_node, spec)
           else
@@ -608,7 +614,7 @@ module BELParser
           children
         end
 
-        def match(value_node, spec)
+        def match(value_node, spec, will_match_partial = false)
           unless value_node.respond_to?(:encoding) && value_node.encoding
             return invalid_encoding_warning(value_node, spec, match_encoding)
           end
@@ -637,7 +643,7 @@ module BELParser
           children
         end
 
-        def match(identifier, spec)
+        def match(identifier, spec, will_match_partial = false)
           return success(identifier, spec) if functions.include?(:*)
 
           function = spec.function(identifier.string_literal.to_sym)
@@ -659,7 +665,7 @@ module BELParser
           children
         end
 
-        def match(identifier, spec)
+        def match(identifier, spec, will_match_partial = false)
           return success(identifier, spec) if return_types.include?(:*)
 
           function = spec.function(identifier.string_literal.to_sym)
@@ -687,7 +693,7 @@ module BELParser
           children
         end
 
-        def match(value_node, spec)
+        def match(value_node, spec, will_match_partial = false)
           string_literal_sym = value_node.children[0].string_literal.to_sym
           return success(value_node, spec) if @hashed[:*]
 
@@ -713,7 +719,7 @@ module BELParser
           children
         end
 
-        def match(value_node, spec)
+        def match(value_node, spec, will_match_partial = false)
           string_literal_sym = value_node.children[0].string_literal.to_sym
           return success(value_node, spec) if @hashed[:*]
 
@@ -735,7 +741,7 @@ module BELParser
           super(:is_amino_acid_range, [], properties)
         end
 
-        def match(value_node, spec)
+        def match(value_node, spec, will_match_partial = false)
           ident_or_string = value_node.children[0]
           value =
             case ident_or_string
@@ -760,7 +766,7 @@ module BELParser
           super(:is_sequence_position, [], properties)
         end
 
-        def match(value_node, spec)
+        def match(value_node, spec, will_match_partial = false)
           string_literal = value_node.children[0].string_literal
           integer_position =
             begin

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bel_parser
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.1.4
 platform: java
 authors:
 - Anthony Bargnesi
@@ -57,6 +57,7 @@ description: Implements language versions 1.0 and 2.0.
 email: abargnesi@selventa.com
 executables:
 - bel2_compatibility
+- bel2_completion
 - bel2_debug_ast
 - bel2_upgrade
 - bel2_validator
@@ -70,6 +71,7 @@ files:
 - README.md
 - VERSION
 - bin/bel2_compatibility
+- bin/bel2_completion
 - bin/bel2_debug_ast
 - bin/bel2_upgrade
 - bin/bel2_validator