bel_parser 1.0.0.alpha.7 → 1.0.0.alpha.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a34f2b2fcde4d9804cccccca0a470bce0d266956
-  data.tar.gz: c3443d26fb7a34c8a65b5ca7275bb77cda43557f
+  metadata.gz: db955e27ca9e82bf06bbd0b3a01d4e7c9f4a00d3
+  data.tar.gz: a4621fb03673bba08e748328d3087cb6b98c2881
 SHA512:
-  metadata.gz: 224d93b78ef97b22a0105ffe03188e20fad89096922c806a2a474d043ba6effe33889ba7162d7aa310bdf34a57355cbb81776099c00c037a9a4d3b62570d45e2
-  data.tar.gz: 907a17075b1053f6f515e434061d51a49f23167bc5f37bd475124b8f4a6f6ba6cc9364b498ddf428f2172c92ab0aae41b2693657331b1d6cdd9806c2448b9110
+  metadata.gz: 42721d3f23244e42a9ea26399964d359bfe334a927ae622fead2255fb33758748aac4e3259cee34e2d4a53ebd5305ec18dd2571be657e86eca3872704c7373e7
+  data.tar.gz: 55a9fd90bb9807075bc240afd9a4fc513c656d638ffb9fb27055d8431746323d7870ad1501de0607f4b84072986233534e82a6a40ad2bfa54096602c17727b81

data/.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
                                  'Anthony Bargnesi',
                                  'Nick Bargnesi',
                                ]
-  spec.date                  = %q{2016-04-11}
+  spec.date                  = %q{2016-04-13}
   spec.email                 = %q{abargnesi@selventa.com}
   spec.files                 = [
                                  Dir.glob('lib/**/*.{rb,rl}'),

data/VERSION

@@ -1 +1 @@
-1.0.0.alpha.7
+1.0.0.alpha.8

data/bin/bel2_validator

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
-$:.unshift(File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib'))
+$LOAD_PATH.unshift(
+  File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib'))
 
 unless ARGV.first
   program = File.basename($PROGRAM_NAME)
@@ -12,6 +13,8 @@ namespaces = Hash[ARGV[1..-1].map { |ns| ns.split('=') }]
 
 require 'bel_parser'
 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
+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/ast_filter.rb

@@ -33,8 +33,8 @@ if __FILE__ == $PROGRAM_NAME
   ast   = BELParser::ASTGenerator.new.each($stdin)
   BELParser::ASTFilter.new(*types).each(ast) do |(line_number, line, results)|
     puts "#{line_number}: #{line}"
-    results.each do |ast|
-      puts ast.to_s(1)
+    results.each do |result_ast|
+      puts result_ast.to_s(1)
     end
   end
 end

data/lib/bel_parser/ast_generator.rb

@@ -21,34 +21,27 @@ module BELParser
     # Yields AST results for each line of the IO.
     #
     # @example Receive AST results in given block.
-    #   # doctest setup
-    #   require 'bel_parser'
-    #   self.class.include AST::Sexp
+    #   # doctest setup require 'bel_parser' self.class.include AST::Sexp
     #
-    #   # example usage
-    #   line_io = StringIO.new("\"AKT1\"\n")
-    #   line    = nil
-    #   ast_res = nil
-    #   ::BELParser::ASTGenerator.new.each(line_io) { |(line_number, line, results)|
+    #   # example usage line_io = StringIO.new("\"AKT1\"\n") line    =
+    #   nil ast_res = nil ::BELParser::ASTGenerator.new.each(line_io)
+    #   { |(line_number, line, results)|
     #     # do something
     #   }
     #
     # @example Receive AST results as an enumerator.
-    #   # doctest setup
-    #   require 'bel_parser'
-    #   self.class.include AST::Sexp
+    #   # doctest setup require 'bel_parser' self.class.include AST::Sexp
     #
-    #   # example usage
-    #   line_io = StringIO.new("\"AKT1\"\n")
-    #   line, ast_res = ::BELParser::ASTGenerator.new.each(line_io).first.to_a
+    #   # example usage line_io = StringIO.new("\"AKT1\"\n") line,
+    #   ast_res = ::BELParser::ASTGenerator.new.each(line_io).first.to_a
     #
-    # @param  [IO] io the IO-object to read each line from
-    # @yield  [[Integer, String, Array<AST::Node>]] yields line number, line,
+    # @param  [IO] io the IO-object to read each line from @yield
+    # [[Integer, String, Array<AST::Node>]] yields line number, line,
     #         and AST results as an {Array}
     # @return [IO, #<Enumerator: #<BELParser::ASTGenerator#each>] the {IO}
     #         object is returned if a block is given, otherwise an
-    #         {Enumerator} object is returned that can be iterated
-    #         with {Enumerator#each}
+    #         {Enumerator} object is returned that can be iterated with
+    #         {Enumerator#each}
     def each(io) # rubocop:disable MethodLength
       if block_given?
         line_enumerator = map_lines(io.each_line.lazy)

data/lib/bel_parser/language/expression_validator.rb

@@ -3,6 +3,9 @@ require_relative 'semantics'
 
 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)
         @spec                = spec
@@ -11,6 +14,11 @@ module BELParser
         @semantics_functions = Semantics.semantics_functions
       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)
         results = syntax(expression_node)
         if results.empty?

data/lib/bel_parser/language/quoting.rb

@@ -1,5 +1,4 @@
 module BELParser
-
   # The Quoting module implements quoting rules consistent with BEL
   # and BEL Script. Double quotes are used to group a string together
   # which may contain whitespace or special characters.
@@ -16,10 +15,9 @@ module BELParser
   # BEL Script: BEL parameters, document property values, and annotation
   # values must be an identifier or string value.
   module Quoting
-
     # Declares BEL Script keywords that cause problems with the OpenBEL
     # Framework parser.
-    Keywords               = %w(SET DEFINE a g p r m)
+    Keywords               = %w(SET DEFINE a g p r m).freeze
 
     # Regular expression that matches one of {Quoting::Keywords}.
     KeywordMatcher         = Regexp.compile(/^(#{Keywords.join('|')})$/)
@@ -54,8 +52,8 @@ module BELParser
     def quote(value)
       string   = value.to_s
       unquoted = unquote(string)
-      escaped  = unquoted.gsub(QuoteNotEscapedMatcher, "\\\"")
-      %Q{"#{escaped}"}
+      escaped  = unquoted.gsub(QuoteNotEscapedMatcher, '\\"')
+      %("#{escaped}")
     end
 
     # Returns +value+ with surrounded quotes removed.
@@ -150,9 +148,9 @@ module BELParser
     #            +false+ if +value+ is not an identifier
     def identifier_value?(value)
       string = value.to_s
-      [NonWordMatcher, KeywordMatcher].none? { |matcher|
+      [NonWordMatcher, KeywordMatcher].none? do |matcher|
         matcher.match string
-      }
+      end
     end
 
     # Returns whether the +value+ represents a string value. A string
@@ -171,21 +169,21 @@ module BELParser
     #            +false+ if +value+ is not a string value
     def string_value?(value)
       string = value.to_s
-      [NonWordMatcher, KeywordMatcher].any? { |matcher|
+      [NonWordMatcher, KeywordMatcher].any? do |matcher|
         matcher.match string
-      }
+      end
     end
 
     ## Deprecated, remove in [0.6.0].
 
     # @deprecated Use {#quote_if_needed} instead. Will be removed in a
     #             future release.
-    def ensure_quotes identifier
+    def ensure_quotes(identifier)
       warn <<-DOC.gsub(/^\s+/, '')
         Deprecation Warning
         -------------------
         The BEL::Quoting::ensure_quotes method is deprecated and
-        will be removed in a future relase.
+        will be removed in a future release.
         Call module method BEL::Quoting.quote_if_needed instead.
       DOC
       quote_if_needed(identifier)
@@ -193,12 +191,12 @@ module BELParser
 
     # @deprecated Use {#unquote} instead. Will be removed in a
     #             future release.
-    def remove_quotes identifier
+    def remove_quotes(identifier)
       warn <<-DOC.gsub(/^\s+/, '')
         Deprecation Warning
         -------------------
         The BEL::Quoting::remove_quotes method is deprecated and
-        will be removed in a future relase.
+        will be removed in a future release.
         Call module method BEL::Quoting.unquote instead.
       DOC
       unquote(identifier)
@@ -206,12 +204,12 @@ module BELParser
 
     # @deprecated Use {#quote} instead. Will be removed in a
     #             future release.
-    def always_quote identifier
+    def always_quote(identifier)
       warn <<-DOC.gsub(/^\s+/, '')
         Deprecation Warning
         -------------------
         The BEL::Quoting::always_quote method is deprecated and
-        will be removed in a future relase.
+        will be removed in a future release.
         Call module method BEL::Quoting.quote instead.
       DOC
       quote(identifier)
@@ -219,18 +217,17 @@ module BELParser
 
     # @deprecated Use {#quoted?} or {#unquoted?} instead. Will be removed
     #             in a future release.
-    def quotes_required? identifier
+    def quotes_required?(identifier)
       warn <<-DOC.gsub(/^\s+/, '')
         Deprecation Warning
         -------------------
-        The BEL::Quoting::quotes_required? method is deprecated and 
-        will be removed in a future relase.
-        You can use BEL::Quoting.quoted? and BEL::Quoting.unquoted?
-        going forward.
+        The BEL::Quoting::quotes_required? method is deprecated and
+        will be removed in a future release. Use BEL::Quoting.quoted? and
+        BEL::Quoting.unquoted?.
       DOC
-      [NonWordMatcher, KeywordMatcher].any? { |m|
+      [NonWordMatcher, KeywordMatcher].any? do |m|
         m.match identifier.to_s
-      }
+      end
     end
   end
 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,36 @@
+require 'bel_parser/parsers/ast/node'
+
+module BELParser
+  module Language
+    module Semantics
+      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
+
+      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
+          %Q{Function "#{deprecated_function}" is deprecated.}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+require 'bel_parser/parsers/ast/node'
+
+module BELParser
+  module Language
+    module Semantics
+      # ListFunctionSubject implements a {SemanticsFunction} that maps a
+      # {BELParser::Parsers::AST::Subject} to {SemanticsWarning} if a _list_
+      # {BELParser::Parsers::AST::Term} is used as the
+      # {BELParser::Parsers::AST::Subject} of a
+      # {BELParser::Parsers::AST::Statement}.
+      class ListFunctionSubject
+        include SemanticsFunction
+
+        private_class_method :new
+
+        def self.map(node, spec, _namespaces)
+          return nil unless node.is_a?(BELParser::Parsers::AST::Subject)
+
+          list_func = spec.function(:list)
+          return nil unless list_func
+
+          func_name = node.term.function.identifier.string_literal
+          sub_func  = spec.function(func_name.to_sym)
+          ListFunctionSubjectWarning.new(node, spec) if sub_func == list_func
+        end
+      end
+
+      # ListFunctionSubjectWarning defines a {SemanticsWarning} that indicates
+      # that a _list_ {BELParser::Parsers::AST::Term} was used as the
+      # {BELParser::Parsers::AST::Subject} of a
+      # {BELParser::Parsers::AST::Statement}.
+      class ListFunctionSubjectWarning < SemanticsWarning
+        def initialize(subject_node, spec)
+          super(subject_node, spec)
+        end
+
+        def to_s
+          <<-MSG.gsub(/ {12}/, '').delete("\n")
+            List term is only valid in the Object of a Statement.
+          MSG
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'bel_parser/parsers/ast/node'
+
+module BELParser
+  module Language
+    module Semantics
+      class RelationshipDeprecation
+        include SemanticsFunction
+
+        private_class_method :new
+
+        def self.map(node, spec, _namespaces)
+          return nil unless node.is_a?(BELParser::Parsers::AST::Relationship)
+
+          relationship_name = node.string_literal
+          rel               = spec.relationship(relationship_name.to_sym)
+          return nil unless rel
+
+          RelationshipDeprecationWarning.new(node, spec, rel) if rel.deprecated?
+        end
+      end
+
+      class RelationshipDeprecationWarning < SemanticsWarning
+        attr_reader :deprecated_relationship
+
+        def initialize(relationship_node, spec, deprecated_relationship)
+          super(relationship_node, spec)
+          @deprecated_relationship = deprecated_relationship
+        end
+
+        def to_s
+          %Q{Relationship "#{deprecated_relationship}" is deprecated.}
+        end
+      end
+    end
+  end
+end

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

@@ -3,24 +3,24 @@ require 'bel_parser/parsers/ast/node'
 module BELParser
   module Language
     module Semantics
+      # SignatureMapping implements a {SemanticsFunction} that maps
+      # a {BELParser::Parsers::AST::Node} to {SemanticsResult} by
+      # checking each {BELParser::Language::Signature signature} for
+      # the {BELParser::Language::Function}.
+      #
+      # @see BELParser::Language::Function#signatures
       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_node, spec, namespaces)
+        # 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)
           return nil unless term_node.is_a?(BELParser::Parsers::AST::Term)
 
-          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_node, sig.semantic_ast, spec)] }
-            .partition { |(sig, results)| results.all?(&:success?) }
+          successes, failures = map_signatures(term_node, spec)
 
           if successes.empty?
             SignatureMappingWarning.new(term_node, spec, failures)
@@ -28,8 +28,20 @@ module BELParser
             SignatureMappingSuccess.new(term_node, spec, successes, failures)
           end
         end
+
+        def self.map_signatures(term_node, spec)
+          function_name = term_node.function.identifier.string_literal
+          function      = spec.function(function_name.to_sym)
+          match = BELParser::Language::Semantics.method(:match)
+          function
+            .signatures
+            .map { |sig| [sig, match.call(term_node, sig.semantic_ast, spec)] }
+            .partition { |(_sig, results)| results.all?(&:success?) }
+        end
       end
 
+      # SignatureMappingSuccess defines a {SemanticsResult} that indicates
+      # a successful signature match.
       class SignatureMappingSuccess < SemanticsResult
         attr_reader :success_signatures
         attr_reader :failure_signatures
@@ -37,13 +49,13 @@ module BELParser
         def initialize(term_node, spec, successes, failures)
           super(term_node, spec)
           @success_signatures = successes
-          @failure_signatures  = failures
+          @failure_signatures = failures
         end
 
         def to_s
           sig_list = success_signatures
-            .map { |(sig, results)| sig.string_form }
-            .join("\n  ")
+                     .map { |(sig, _results)| sig.string_form }
+                     .join("\n  ")
           <<-MSG.gsub(/ {12}/, '').gsub(/\n$/, '')
             Term matches function signatures:
               #{sig_list}
@@ -51,6 +63,8 @@ module BELParser
         end
       end
 
+      # SignatureMappingWarning defines a {SemanticsWarning} that indicates
+      # an unsuccessful signature match.
       class SignatureMappingWarning < SemanticsWarning
         attr_reader :failure_signatures
 
@@ -61,8 +75,8 @@ module BELParser
 
         def to_s
           sig_list = failure_signatures
-            .map { |(sig, results)| sig.string_form }
-            .join("\n  ")
+                     .map { |(sig, _results)| sig.string_form }
+                     .join("\n  ")
           <<-MSG.gsub(/ {12}/, '').gsub(/\n$/, '')
             Term did not conform to function signatures:
               #{sig_list}

data/lib/bel_parser/language/semantics.rb

@@ -6,16 +6,21 @@ 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
-        self.constants.collect do |symbol|
-          const = self.const_get(symbol)
+        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.'

data/lib/bel_parser/language/semantics_ast.rb

@@ -4,8 +4,8 @@ require_relative '../parsers/ast/node'
 
 module BELParser
   module Language
-    # Semantics capture BEL version-independent semantics for terms and
-    # statements.
+    # Semantics capture BEL version-independent semantics for terms
+    # and statements.
     module Semantics
       # rubocop:disable Metrics/MethodLength
       # rubocop:disable Metrics/AbcSize
@@ -15,16 +15,23 @@ module BELParser
         if res.flatten.all?(&:success?) && !semantic_ast.terminal?
           return match_results if semantic_ast.children.empty?
 
-          var_test = semantic_ast.children.any? { |x| x.is_a?(SemanticVariadicArguments) }
+          var_test = semantic_ast.children.any? do |x|
+            x.is_a?(SemanticVariadicArguments)
+          end
           if var_test
-            test_pairs = input_ast.children.zip(semantic_ast.children).select do |pair|
-              !pair.include?(nil)
-            end
+            test_pairs =
+              input_ast
+              .children
+              .zip(semantic_ast.children)
+              .select do |pair|
+                !pair.include?(nil)
+              end
 
             test_pairs.each do |(input_child, semantic_child)|
               if semantic_child.is_a?(SemanticVariadicArguments)
                 input_children   = input_ast.children
-                input_arguments  = input_children[input_children.index(input_child)..-1]
+                input_arguments  =
+                  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)
@@ -323,10 +330,7 @@ module BELParser
           return failure(nil) if identifier.nil?
           return failure(identifier) if type != identifier.type
 
-          value_results = value_patterns.map do |pattern|
-            pattern.match(identifier, spec)
-          end
-
+          value_results  = match_value_patterns(identifier, spec)
           failure_result = value_results.flatten.find(&:failure?)
 
           if failure_result
@@ -335,6 +339,12 @@ module BELParser
             value_results.unshift(success(identifier))
           end
         end
+
+        private
+
+        def match_value_patterns(identifier, spec)
+          value_patterns.map { |pattern| pattern.match(identifier, spec) }
+        end
       end
 
       # AST node for Any is a semantic AST.
@@ -559,7 +569,7 @@ module BELParser
       class SemanticIsAminoAcidRange < SemanticASTNode
         START_STOP         = /[1-9][0-9]*_[1-9][0-9]*/
         UNDETERMINED       = /[1?]_[?*]/
-        UNKNOWN_START_STOP = "?"
+        UNKNOWN_START_STOP = '?'.freeze
 
         include BELParser::Quoting
 

data/lib/bel_parser/language/semantics_function.rb

@@ -1,10 +1,13 @@
 module BELParser
   module Language
     module Semantics
+      # SemanticsFunction provides a {#map} function that maps a
+      # {BELParser::Parsers::AST::Node} to one or more
+      # {SemanticsResult semantics results}.
       module SemanticsFunction
         # @abstract Include {SemanticsFunction} and override {#map} to check
         # term semantics (e.g. signatures).
-        def self.map(term_ast, spec, namespaces)
+        def self.map(_term_ast, _spec, _namespaces)
           raise NotImplementedError, "#{__method__} is not implemented."
         end
       end

data/lib/bel_parser/language/semantics_result.rb

@@ -1,6 +1,7 @@
 module BELParser
   module Language
     module Semantics
+      # SemanticsResult represents the result of running a {SemanticsFunction}.
       class SemanticsResult
         attr_reader :expression_node, :specification
 

data/lib/bel_parser/language/semantics_warning.rb

@@ -3,6 +3,8 @@ require_relative 'semantics_result'
 module BELParser
   module Language
     module Semantics
+      # SemanticsWarning defines a {SemanticsResult} that should be regarded as
+      # a warning with the expression.
       class SemanticsWarning < SemanticsResult
         def initialize(expression_node, specification)
           super(expression_node, specification)