bel_parser 1.0.0.alpha.13 → 1.0.0.alpha.14

data/lib/bel_parser/parsers/common/list.rl

@@ -25,9 +25,11 @@
 
   action append_list {
     # Append list argument if its value is not empty.
-    list_arg_value = @buffers[:list_arg].children[0].children[0]
-    if list_arg_value != ''
-      @buffers[:list] <<= @buffers[:list_arg]
+    if @buffers[:list_arg]
+      list_arg_value = @buffers[:list_arg].children[0].children[0]
+      if list_arg_value != ''
+        @buffers[:list] <<= @buffers[:list_arg]
+      end
     end
   }
 
@@ -60,7 +62,7 @@
     (
       STRING %string $err(error_list_string) |
       IDENT  %ident  $err(error_list_ident)
-    ) $err(append_list) %append_list
+    )? $err(append_list) %append_list
     SP*
     (
       ',' @clear

data/lib/bel_parser/resource/eager_reader.rb

@@ -34,7 +34,7 @@ module BELParser
           return cached_concept if cached_concept
         end
         
-        EMPTY_ARRAY
+        nil
       end
 
       def retrieve_values_from_resource(resource_identifier)
@@ -52,17 +52,17 @@ module BELParser
         if lock.try_lock
           Thread.new do
             value_hash = {
-              :name       => Hash.new { |hash, key| hash[key] = [] },
-              :identifier => Hash.new { |hash, key| hash[key] = [] },
-              :title      => Hash.new { |hash, key| hash[key] = [] },
-              :synonyms   => Hash.new { |hash, key| hash[key] = [] }
+              :name       => {},
+              :identifier => {},
+              :title      => {},
+              :synonyms   => {}
             }
             retrieve_values_from_resource(identifier).each do |concept|
-              value_hash[:name][concept.name] << concept
-              value_hash[:identifier][concept.identifier] << concept
-              value_hash[:title][concept.title] << concept
+              value_hash[:name][concept.name]             = concept
+              value_hash[:identifier][concept.identifier] = concept
+              value_hash[:title][concept.title]           = concept
               concept.synonyms.each do |synonym|
-                value_hash[:synonyms][synonym] << concept
+                value_hash[:synonyms][synonym] = concept
               end
             end
             resources[identifier] = value_hash

data/lib/bel_parser/resource/http_cache.rb

@@ -32,24 +32,42 @@ module BELParser
             end
           else
             uri = URI.parse(url)
-            cached_file = File.open(cached_url_path, 'w')
             begin
               Net::HTTP.start(uri.host, uri.port) do |http|
                 http.request(Net::HTTP::Get.new(uri)) do |response|
+
                   if block_given?
-                    response.read_body do |chunk|
-                      cached_file.write(chunk)
-                      yield StringIO.new(chunk)
+                    if response.is_a?(Net::HTTPOK)
+                      cached_file = File.open(cached_url_path, 'w')
+                      response.read_body do |chunk|
+                        cached_file.write(chunk)
+                        yield StringIO.new(chunk)
+                      end
+                    else
+                      yield nil
                     end
                   else
-                    content = response.read_body
-                    cached_file.write(content)
-                    return StringIO.new(content)
+                    if response.is_a?(Net::HTTPOK)
+                      cached_file = File.open(cached_url_path, 'w')
+                      content = response.read_body
+                      cached_file.write(content)
+                      return StringIO.new(content)
+                    else
+                      return nil
+                    end
                   end
                 end
               end
+            rescue SocketError
+              if block_given?
+                yield nil
+              else
+                return nil
+              end
             ensure
-              cached_file.close
+              if defined? cached_file
+                cached_file.close
+              end
             end
           end
         end

data/lib/bel_parser/resource/resource_file_reader.rb

@@ -74,6 +74,7 @@ module BELParser
 
       def read_resource(url)
         io = @http_cache.get(url)
+        return nil unless io
 
         type, name, keyword, domain = nil
         io.each_line do |line|

data/lib/bel_parser/resource/sparql_reader.rb

@@ -60,6 +60,7 @@ module BELParser
       end
 
       def hash_to_concept_scheme(resource_identifier, hash)
+        return nil if hash[:types].value.empty?
         ConceptScheme.new(resource_identifier, 
           *hash.values_at(:domain, :prefix, :prefLabel, :types))
       end

data/lib/bel_parser/script/state/annotation_definition.rb

@@ -0,0 +1,62 @@
+require 'bel_parser/language'
+require 'bel_parser/quoting'
+require 'bel_parser/parsers/ast/node'
+require 'concurrent/hash'
+require_relative '../state_function'
+
+module BELParser
+  module Script
+    module State
+      class AnnotationDefinition
+        extend StateFunction
+        extend BELParser::Quoting
+
+        TARGET_NODE = BELParser::Parsers::AST::AnnotationDefinition
+
+        def self.consume(ast_node, script_context)
+          return nil unless ast_node.is_a?(TARGET_NODE)
+          resource_reader = script_context[:resource_reader]
+
+          keyword, domain = ast_node.children
+          prefix          = keyword.identifier.string_literal
+          case
+          when domain.list?
+            handle_list(prefix, domain.child, script_context)
+          when domain.url?
+            handle_url(prefix, domain.child, script_context)
+          when domain.pattern?
+            handle_pattern(prefix, domain.child, script_context)
+          end
+        end
+
+        def self.handle_list(prefix, list_node, script_context)
+          script_context[:annotation_definitions] ||= Concurrent::Hash.new
+          script_context[:annotation_definitions][prefix] = [
+            :list,
+            list_node.list_items.map do |li|
+              unquote(li.children[0].string_literal)
+            end
+          ]
+        end
+        private_class_method :handle_list
+
+        def self.handle_pattern(prefix, pattern_node, script_context)
+          script_context[:annotation_definitions] ||= Concurrent::Hash.new
+          script_context[:annotation_definitions][prefix] = [
+            :pattern,
+            unquote(pattern_node.string)
+          ]
+        end
+        private_class_method :handle_pattern
+
+        def self.handle_url(prefix, url_node, script_context)
+          url     = unquote(url_node.string.string_literal)
+          dataset = script_context[:resource_reader].retrieve_resource(url)
+          script_context[:annotation_definitions] ||= Concurrent::Hash.new
+          script_context[:annotation_definitions][prefix] = [:url, dataset]
+        end
+        private_class_method :handle_url
+      end
+    end
+  end
+end

data/lib/bel_parser/script/state/bel_version.rb

@@ -0,0 +1,35 @@
+require 'bel_parser/language'
+require 'bel_parser/parsers/ast/node'
+require 'bel_parser/quoting'
+require 'concurrent/hash'
+require_relative '../state_function'
+
+module BELParser
+  module Script
+    module State
+      class BELVersion
+        extend StateFunction
+        extend BELParser::Quoting
+
+        TARGET_NODE         = BELParser::Parsers::AST::DocumentProperty
+        BEL_VERSION_REGEX   = /#{Regexp.escape('bel_version')}/i
+        DEFAULT_BEL_VERSION = '2.0'
+
+        def self.consume(ast_node, script_context)
+          return unless ast_node.is_a?(TARGET_NODE)
+          name, value = ast_node.children
+          name_string  = name.identifier.string_literal
+          return unless name_string =~ BEL_VERSION_REGEX
+
+          value_string = unquote(value.children[0].string_literal)
+          begin
+            spec = BELParser::Language.specification(value_string)
+          rescue ArgumentError
+            spec = BELParser::Language.specification(DEFAULT_BEL_VERSION)
+          end
+          script_context[:specification] = spec
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/script/state/document_property.rb

@@ -0,0 +1,29 @@
+require 'bel_parser/parsers/ast/node'
+require 'bel_parser/quoting'
+require 'concurrent/hash'
+require_relative '../state_function'
+
+module BELParser
+  module Script
+    module State
+      class DocumentProperty
+        extend StateFunction
+        extend BELParser::Quoting
+
+        TARGET_NODE = BELParser::Parsers::AST::DocumentProperty
+
+        def self.consume(ast_node, script_context)
+          return nil unless ast_node.is_a?(TARGET_NODE)
+          hash = script_context[:document_properties] ||= Concurrent::Hash.new
+
+          name, value = ast_node.children
+          if name && value
+            name_string  = name.identifier.string_literal
+            value_string = value.children[0].string_literal
+            hash[name_string] = unquote(value_string)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/script/state/namespace_definition.rb

@@ -0,0 +1,32 @@
+require 'bel_parser/language'
+require 'bel_parser/quoting'
+require 'bel_parser/parsers/ast/node'
+require 'concurrent/hash'
+require_relative '../state_function'
+
+module BELParser
+  module Script
+    module State
+      class NamespaceDefinition
+        extend StateFunction
+        extend BELParser::Quoting
+
+        TARGET_NODE = BELParser::Parsers::AST::NamespaceDefinition
+
+        def self.consume(ast_node, script_context)
+          return nil unless ast_node.is_a?(TARGET_NODE)
+          resource_reader = script_context[:resource_reader]
+
+          keyword, domain = ast_node.children
+          if domain.url?
+            prefix  = keyword.identifier.string_literal
+            url     = unquote(domain.child.string.string_literal)
+            dataset = resource_reader.retrieve_resource(url)
+            script_context[:namespace_definitions] ||= Concurrent::Hash.new
+            script_context[:namespace_definitions][prefix] = dataset
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/script/state/set.rb

@@ -0,0 +1,57 @@
+require 'bel_parser/language'
+require 'bel_parser/quoting'
+require 'bel_parser/parsers/ast/node'
+require 'concurrent/hash'
+require_relative '../state_function'
+
+module BELParser
+  module Script
+    module State
+      class Set
+        extend StateFunction
+        extend BELParser::Quoting
+
+        TARGET_NODE = BELParser::Parsers::AST::Set
+        LIST_NODE   = BELParser::Parsers::AST::List
+
+        def self.consume(ast_node, script_context)
+          return nil unless ast_node.is_a?(TARGET_NODE)
+          name, value = ast_node.children
+          name_string = name.identifier.string_literal
+          value_node  = ast_node.value.children[0]
+          if value_node.is_a?(LIST_NODE)
+            value_node
+              .list_items.map { |li| li.children[0].string_literal }
+              .each do |string|
+                handle_annotation(name_string, string, script_context)
+              end
+          else
+            value_string = value_node.string_literal
+            case name_string
+            when /\ASTATEMENT_GROUP\Z/
+              handle_statement_group(value_string, script_context)
+            else
+              handle_annotation(name_string, value_string, script_context)
+            end
+          end
+        end
+
+        def self.handle_annotation(name, value, script_context)
+          # add to annotation state
+          script_context[:annotations]       ||= Concurrent::Hash.new
+          script_context[:annotations][name]   = value
+        end
+        private_class_method :handle_annotation
+
+        def self.handle_statement_group(value, script_context)
+          script_context[:statement_group] = value
+
+          # clear annotation state
+          script_context[:annotations]     ||= Concurrent::Hash.new
+          script_context[:annotations].clear
+        end
+        private_class_method :handle_statement_group
+      end
+    end
+  end
+end

data/lib/bel_parser/script/state/unset.rb

@@ -0,0 +1,43 @@
+require 'bel_parser/language'
+require 'bel_parser/quoting'
+require 'bel_parser/parsers/ast/node'
+require 'concurrent/hash'
+require_relative '../state_function'
+
+module BELParser
+  module Script
+    module State
+      class Unset
+        extend StateFunction
+        extend BELParser::Quoting
+
+        TARGET_NODE = BELParser::Parsers::AST::Unset
+
+        def self.consume(ast_node, script_context)
+          return nil unless ast_node.is_a?(TARGET_NODE)
+          name_string = ast_node.name.identifier.string_literal
+          case name_string
+          when /\ASTATEMENT_GROUP\Z/
+            handle_statement_group(script_context)
+          else
+            handle_annotation(name_string, script_context)
+          end
+        end
+
+        def self.handle_annotation(name, script_context)
+          script_context[:annotations] ||= Concurrent::Hash.new
+          script_context[:annotations].delete(name)
+        end
+        private_class_method :handle_annotation
+
+        def self.handle_statement_group(script_context)
+          script_context.delete(:statement_group)
+
+          script_context[:annotations] ||= Concurrent::Hash.new
+          script_context[:annotations].clear
+        end
+        private_class_method :handle_statement_group
+      end
+    end
+  end
+end

data/lib/bel_parser/script/state_function.rb

@@ -0,0 +1,10 @@
+module BELParser
+  module Script
+    module StateFunction
+      # @abstract Extend {StateFunction} and override {#consume}.
+      def consume(ast_node, script_context)
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+    end
+  end
+end

data/lib/bel_parser/script/syntax/expression_validation.rb

@@ -0,0 +1,46 @@
+require 'bel_parser/language'
+require 'bel_parser/language/expression_validator'
+require 'bel_parser/language/syntax_function'
+require 'bel_parser/language/syntax_warning'
+require 'bel_parser/quoting'
+require 'bel_parser/parsers/ast/node'
+require 'concurrent/hash'
+
+module BELParser
+  module Script
+    module Syntax
+      class ExpressionValidation
+        extend BELParser::Language::Syntax::SyntaxFunction
+        extend BELParser::Quoting
+
+        TARGET_NODES = [
+          BELParser::Parsers::AST::ObservedTerm,
+          BELParser::Parsers::AST::SimpleStatement,
+          BELParser::Parsers::AST::NestedStatement
+        ]
+        EXP_VALIDATOR = BELParser::Language::ExpressionValidator
+
+        def self.map(ast_node, script_context)
+          return nil unless TARGET_NODES.include?(ast_node.class)
+          return nil unless script_context.key?(:specification)
+
+          validator = expression_validator(script_context)
+          validator.validate(ast_node).select(&:failure?)
+        end
+
+        def self.expression_validator(script_context)
+          unless defined? @expression_validator
+            spec, namespaces, reader =
+              script_context
+              .values_at(
+                :specification,
+                :namespace_definitions,
+                :resource_reader)
+            @expression_validator = EXP_VALIDATOR.new(spec, namespaces, reader)
+          end
+          @expression_validator
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/script/syntax/invalid_regex_pattern.rb

@@ -0,0 +1,49 @@
+require 'bel_parser/language'
+require 'bel_parser/language/syntax_function'
+require 'bel_parser/language/syntax_error'
+require 'bel_parser/quoting'
+require 'bel_parser/parsers/ast/node'
+require 'concurrent/hash'
+
+module BELParser
+  module Script
+    module Syntax
+      class InvalidRegexPattern
+        extend BELParser::Language::Syntax::SyntaxFunction
+        extend BELParser::Quoting
+
+        TARGET_NODE = BELParser::Parsers::AST::Pattern
+
+        def self.map(ast_node, script_context)
+          return nil unless ast_node.is_a?(TARGET_NODE)
+          pattern = unquote(ast_node.string.string_literal)
+          begin
+            Regexp.new(pattern)
+            nil
+          rescue RegexpError => error
+            InvalidRegexPatternError.new(ast_node, pattern, error.to_s)
+          end
+        end
+      end
+
+      # InvalidRegexPattern indicates that a pattern represented an invalid
+      # regular expression.
+      class InvalidRegexPatternError < BELParser::Language::Syntax::SyntaxError
+        # Gets the invalid pattern.
+        attr_reader :pattern
+
+        def initialize(pattern_node, pattern, error_msg)
+          super(pattern_node, nil)
+          @pattern   = pattern
+          @error_msg = error_msg
+        end
+
+        def msg
+          <<-MSG.gsub(/^ +/, '').delete("\n")
+            "#@pattern" is not a valid regular expression (#@error_msg).
+          MSG
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/script/syntax/undefined_annotation.rb

@@ -0,0 +1,60 @@
+require 'bel_parser/language'
+require 'bel_parser/language/syntax_function'
+require 'bel_parser/language/syntax_error'
+require 'bel_parser/quoting'
+require 'bel_parser/parsers/ast/node'
+require 'concurrent/hash'
+
+module BELParser
+  module Script
+    module Syntax
+      class UndefinedAnnotation
+        extend BELParser::Language::Syntax::SyntaxFunction
+
+        TARGET_NODE       = BELParser::Parsers::AST::Set
+        IMPLICIT_KEYWORDS = ['Citation', 'Evidence', 'STATEMENT_GROUP']
+
+        def self.map(ast_node, script_context)
+          return nil unless ast_node.is_a?(TARGET_NODE)
+          name_string = ast_node.name.identifier.string_literal
+          annotation_definitions =
+            script_context[:annotation_definitions] ||= Concurrent::Hash.new
+
+          return nil if IMPLICIT_KEYWORDS.include?(name_string)
+          return nil if annotation_definitions.key?(name_string)
+          UndefinedAnnotationError.new(
+            ast_node,
+            name_string,
+            script_context[:annotation_definitions])
+        end
+      end
+
+      # UndefinedAnnotationError represents an undefined annotation seen when
+      # checking a SET annotation.
+      class UndefinedAnnotationError < BELParser::Language::Syntax::SyntaxError
+        # Gets the undefined prefix.
+        attr_reader :prefix
+
+        def initialize(set_node, prefix, annotation_definitions)
+          super(set_node, nil)
+          @prefix                 = prefix
+          @annotation_definitions = annotation_definitions
+        end
+
+        def msg
+          defined_annotations =
+            if @annotation_definitions.empty?
+              'No annotations are defined.'
+            else
+              annotation_prefixes = @annotation_definitions.keys.join(', ')
+              "Defined annotations: #{annotation_prefixes}"
+            end
+          <<-MSG.gsub(/^ +/, '').delete("\n")
+            Annotation definition is missing for "#@prefix". 
+            #{defined_annotations}
+          MSG
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/script/syntax/undefined_annotation_value.rb

@@ -0,0 +1,83 @@
+require 'bel_parser/language'
+require 'bel_parser/language/syntax_function'
+require 'bel_parser/language/syntax_warning'
+require 'bel_parser/quoting'
+require 'bel_parser/parsers/ast/node'
+require 'concurrent/hash'
+
+module BELParser
+  module Script
+    module Syntax
+      class UndefinedAnnotationValue
+        extend BELParser::Language::Syntax::SyntaxFunction
+        extend BELParser::Quoting
+
+        TARGET_NODE       = BELParser::Parsers::AST::Set
+        LIST_NODE         = BELParser::Parsers::AST::List
+        IMPLICIT_KEYWORDS = ['Citation', 'Evidence', 'STATEMENT_GROUP']
+
+        def self.map(ast_node, script_context)
+          return nil unless ast_node.is_a?(TARGET_NODE)
+          name, value  = ast_node.children
+          name_string  = ast_node.name.identifier.string_literal
+
+          return nil if IMPLICIT_KEYWORDS.include?(name_string)
+          dataset = annotation(name_string, script_context)
+          return nil unless dataset
+
+          rr         = script_context[:resource_reader]
+          value_node = ast_node.value.children[0]
+          if value_node.is_a?(LIST_NODE)
+            value_node
+              .list_items.map { |li| li.children[0].string_literal }
+              .map do |string|
+                map_value(ast_node, name_string, string, dataset.identifier, rr)
+              end
+          else
+            map_value(
+              ast_node,
+              name_string,
+              value_node.string_literal,
+              dataset.identifier,
+              rr)
+          end
+        end
+
+        def self.annotation(name_string, script_context)
+          hash =
+            script_context[:annotation_definitions] ||= Concurrent::Hash.new
+          type, definition = hash[name_string]
+          type == :url ? definition : nil
+        end
+
+        def self.map_value(ast_node, name_string, value_string, identifier, rr)
+          value_string = unquote(value_string)
+          value = rr.retrieve_value_from_resource(identifier, value_string)
+          UndefinedAnnotationValueWarning.new(
+            ast_node,
+            name_string,
+            value_string) unless value
+        end
+      end
+
+      # UndefinedAnnotationValueWarning represents an undefined annotation value
+      # while checking a SET annotation.
+      class UndefinedAnnotationValueWarning < BELParser::Language::Syntax::SyntaxWarning
+        # Gets the prefix.
+        attr_reader :prefix
+        # Gets the undefined annotation value.
+        attr_reader :value
+
+        def initialize(set_node, prefix, value)
+          super(set_node, nil)
+          @prefix = prefix
+          @value  = value
+        end
+
+        def msg
+          %(Undefined annotation value "#@value" for annotation "#@prefix".)
+        end
+      end
+    end
+  end
+end