bel_parser 1.0.0.alpha.44 → 1.0.0.alpha.45

data/lib/bel_parser/parsers/bel_script/define_namespace.rl

@@ -16,14 +16,21 @@
   action add_string_value {
     trace('DEFINE_NAMESPACE add_string_value')
     string_node = @buffers.delete(:string)
-    leaf = domain(url(string_node))
+    domain   = @buffers.delete(:namespace_definition_domain)
+    domain <<= string_node
+    leaf = domain(domain)
     leaf.complete = string_node.complete
     @buffers[:namespace_definition_domain] = leaf
   }
 
+  action add_uri_domain {
+    trace('DEFINE_NAMESPACE add_uri_domain')
+    @buffers[:namespace_definition_domain] = uri()
+  }
+
   action add_url_domain {
     trace('DEFINE_NAMESPACE add_url_domain')
-    @url_domain = true
+    @buffers[:namespace_definition_domain] = url()
   }
 
   action define_namespace_end {
@@ -66,6 +73,11 @@
     %add_string_value
     ;
 
+  uri_domain =
+    KW_URI
+    %add_uri_domain
+    ;
+
   url_domain =
     KW_URL
     %add_url_domain
@@ -79,7 +91,7 @@
     SP+
     KW_AS
     SP+
-    url_domain
+    (url_domain | uri_domain)
     SP+
     string_value
     @eof(define_namespace_node_eof)

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

@@ -28,6 +28,7 @@ machine bel;
   KW_LIST = /LIST/i;
   KW_PATTERN = /PATTERN/i;
   KW_URL = /URL/i;
+  KW_URI = /URI/i;
   KW_DOCUMENT = /DOCUMENT/i;
 
   DEFINE_ANNOTATION =

data/lib/bel_parser/resource/resource_url_reader.rb

@@ -30,7 +30,7 @@ module BELParser
       #
       # @param [Boolean] reuse_database_files specify +true+ to reuse database
       #        files; +false+ to create new database files (default)
-      def initialize(reuse_database_files = false)
+      def initialize(reuse_database_files = true)
         @resources = {}
         @datasets  = ResourceURLReader.open_datasets_file
         @reuse     = reuse_database_files
@@ -50,7 +50,7 @@ module BELParser
         resource = read_resource(resource_identifier)
         encoding = resource[:values][value]
         return nil unless encoding
-        FileResourceValue.new(resource[:dataset], value, encoding)
+        [FileResourceValue.new(resource[:dataset], value, encoding)]
       end
 
       def retrieve_values_from_resource(resource_identifier)

data/lib/bel_parser/resource.rb

@@ -1,14 +1,19 @@
+require          'net/http'
 require_relative 'resource/sparql_reader'
 require_relative 'resource/resource_url_reader'
 
 module BELParser
   module Resource
 
-    # DEFAULT_SPARQL_ENDPOINT = 'http://sparql.openbel.org/identifiers/sparql'
-    DEFAULT_SPARQL_ENDPOINT = 'http://localhost:3030/identifiers/sparql'
+    DEFAULT_SPARQL_ENDPOINT = 'http://build.openbel.org/sparql'
+    #DEFAULT_SPARQL_ENDPOINT = 'http://localhost:3030/identifiers/sparql'
 
-    READER_LOCK = Mutex.new
+    READER_LOCK       = Mutex.new
     private_constant :READER_LOCK
+    RESOLVE_URI_LOCK  = Mutex.new
+    private_constant :RESOLVE_URI_LOCK
+    URISTRING_PATTERN = /^URIString *= *(.*)$/
+    private_constant :URISTRING_PATTERN
 
     def self.default_uri_reader
       READER_LOCK.synchronize do
@@ -33,5 +38,47 @@ module BELParser
         @default_url_reader ||= url_reader
       end
     end
+
+    # Resolves the URI String from the annotation or namespace resource.
+    #
+    # The resource must contain a _URIString=..._ property.
+    #
+    # @param  [#to_s] resource_url the resource URL to resolve the URI from
+    # @return [String] the resource URI specified in the resource
+    def self.resolve_uri(resource_url)
+      resource_url = resource_url.to_s
+
+      RESOLVE_URI_LOCK.synchronize do
+        @uri_hash ||= {}
+        return @uri_hash[resource_url] if @uri_hash.key?(resource_url)
+      end
+
+      uri              = URI(resource_url)
+      request          = Net::HTTP::Get.new(uri)
+      request['Range'] = 'bytes=0-5000'
+      resource_uri     = nil
+
+      Net::HTTP.start(
+        uri.hostname,
+        uri.port) { |http|
+
+        http.request(request) do |response|
+          response.read_body do |chunk|
+            uristring    = chunk.lines.detect { |l| l =~ URISTRING_PATTERN }
+            if uristring
+              resource_uri = uristring.match(URISTRING_PATTERN)[1]
+              break
+            end
+          end
+        end
+      }
+
+      RESOLVE_URI_LOCK.synchronize do
+        @uri_hash ||= {}
+        @uri_hash[resource_url] = resource_uri
+      end
+
+      resource_uri
+    end
   end
 end

data/lib/bel_parser/script/apply_resource_uri.rb

@@ -0,0 +1,30 @@
+module BELParser
+  module Script
+    # ApplyResourceURI applies the _uri_ property to
+    # {BELParser::Parsers::AST::AnnotationDefinition} and
+    # {BELParser::Parsers::AST::NamespaceDefinition} child nodes.
+    class ApplyResourceURI
+      include AST::Processor::Mixin
+
+      def on_annotation_definition(node)
+        update_uri_property(node)
+      end
+
+      def on_namespace_definition(node)
+        update_uri_property(node)
+      end
+
+      private
+
+      def update_uri_property(node)
+        domain = node.domain
+        if domain.url?
+          resource_url = domain.child.string.string_literal
+          node.uri     = BELParser::Resource.resolve_uri(resource_url)
+        end
+
+        node
+      end
+    end
+  end
+end

data/lib/bel_parser/script/nanopub_mapper.rb

@@ -116,10 +116,11 @@ module BELParser
               domain:  domain_value(type, domain)
             }
           end,
-          namespaces: (ns_defs || []).map do |keyword, uri|
+          namespaces: (ns_defs || []).map do |keyword, (type, domain)|
             {
               keyword: keyword,
-              uri:     domain_value(:uri, uri)
+              type:    type,
+              domain:  domain_value(type, domain)
             }
           end
         }
@@ -151,17 +152,20 @@ if __FILE__ == $PROGRAM_NAME
   require 'bel_parser/resource/resource_url_reader'
   include BELParser::Script
 
-  rr = BELParser::Resource::ResourceURLReader.new(true)
+  uri_reader = BELParser::Resource.default_uri_reader
+  url_reader = BELParser::Resource::ResourceURLReader.new(true)
+
   namespaces = Hash[
     ARGV.map do |ns|
       prefix, identifier = ns.split('=')
-      dataset            = rr.retrieve_resource(identifier)
+      dataset            = uri_reader.retrieve_resource(identifier)
       dataset ? [prefix, dataset] : nil
     end.compact
   ]
 
   initial_state = {
-    resource_reader:       rr,
+    uri_reader:            uri_reader,
+    url_reader:            url_reader,
     specification:         BELParser::Language.specification('2.0'),
     namespace_definitions: namespaces
   }

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

@@ -1,29 +1,38 @@
 require 'bel_parser/language'
-require 'bel_parser/quoting'
 require 'bel_parser/parsers/ast/node'
 require 'concurrent/hash'
 require_relative '../state_function'
+require_relative '../apply_resource_uri'
 
 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]
+          uri_reader = script_context[:uri_reader]
+          url_reader = script_context[:url_reader]
 
           keyword, domain = ast_node.children
           prefix          = keyword.identifier.string_literal
           case
           when domain.list?
             handle_list(prefix, domain.child, script_context)
+          when domain.uri?
+            uri = domain.child.string.string_literal
+            handle_uri(prefix, uri, script_context)
           when domain.url?
-            handle_url(prefix, domain.child, script_context)
+            ApplyResourceURI.new.process(ast_node)
+            if ast_node.uri
+              handle_uri(prefix, ast_node.uri, script_context)
+            else
+              url = domain.child.string.string_literal
+              handle_url(prefix, url, script_context)
+            end
           when domain.pattern?
             handle_pattern(prefix, domain.child, script_context)
           end
@@ -34,7 +43,7 @@ module BELParser
           script_context[:annotation_definitions][prefix] = [
             :list,
             list_node.list_items.map do |li|
-              unquote(li.children[0].string_literal)
+              li.children[0].string_literal
             end
           ]
         end
@@ -44,14 +53,20 @@ module BELParser
           script_context[:annotation_definitions] ||= Concurrent::Hash.new
           script_context[:annotation_definitions][prefix] = [
             :pattern,
-            unquote(pattern_node.string)
+            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)
+        def self.handle_uri(prefix, uri, script_context)
+          dataset = script_context[:uri_reader].retrieve_resource(uri)
+          script_context[:annotation_definitions] ||= Concurrent::Hash.new
+          script_context[:annotation_definitions][prefix] = [:uri, dataset]
+        end
+        private_class_method :handle_uri
+
+        def self.handle_url(prefix, url, script_context)
+          dataset = script_context[:url_reader].retrieve_resource(url)
           script_context[:annotation_definitions] ||= Concurrent::Hash.new
           script_context[:annotation_definitions][prefix] = [:url, dataset]
         end

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

@@ -1,29 +1,43 @@
 require 'bel_parser/language'
-require 'bel_parser/quoting'
 require 'bel_parser/parsers/ast/node'
 require 'concurrent/hash'
 require_relative '../state_function'
+require_relative '../apply_resource_uri'
 
 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]
+          uri_reader = script_context[:uri_reader]
+          url_reader = script_context[:url_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)
+          prefix          = keyword.identifier.string_literal
+
+          case
+          when domain.uri?
+            uri     = domain.child.string.string_literal
+            dataset = uri_reader.retrieve_resource(uri)
             script_context[:namespace_definitions] ||= Concurrent::Hash.new
-            script_context[:namespace_definitions][prefix] = dataset
+            script_context[:namespace_definitions][prefix] = [:uri, dataset]
+          when domain.url?
+            ApplyResourceURI.new.process(ast_node)
+            if ast_node.uri
+              dataset = uri_reader.retrieve_resource(ast_node.uri)
+              script_context[:namespace_definitions] ||= Concurrent::Hash.new
+              script_context[:namespace_definitions][prefix] = [:uri, dataset]
+            else
+              url     = domain.child.string.string_literal
+              dataset = url_reader.retrieve_resource(url)
+              script_context[:namespace_definitions] ||= Concurrent::Hash.new
+              script_context[:namespace_definitions][prefix] = [:url, dataset]
+            end
           end
         end
       end

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

@@ -30,13 +30,14 @@ module BELParser
 
         def self.expression_validator(script_context)
           unless defined? @expression_validator
-            spec, namespaces, reader =
-              script_context
-              .values_at(
+            spec, namespaces, uri_reader, url_reader =
+              script_context.values_at(
                 :specification,
                 :namespace_definitions,
-                :resource_reader)
-            @expression_validator = EXP_VALIDATOR.new(spec, namespaces, reader)
+                :uri_reader,
+                :url_reader)
+            @expression_validator = EXP_VALIDATOR.new(
+              spec, namespaces, uri_reader, url_reader)
           end
           @expression_validator
         end

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

@@ -23,16 +23,22 @@ module BELParser
           name_string  = ast_node.name.identifier.string_literal
 
           return nil if is_implicit_annotation?(name_string)
-          dataset = annotation(name_string, script_context)
-          return nil unless dataset
+          type, dataset = annotation(name_string, script_context)
+          return nil unless type == :uri || type == :url
 
-          rr         = script_context[:resource_reader]
+          reader =
+            case type
+            when :uri
+              script_context[:uri_reader]
+            when :url
+              script_context[:url_reader]
+            end
           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)
+                map_value(ast_node, name_string, string, dataset.identifier, reader)
               end
           else
             map_value(
@@ -40,20 +46,19 @@ module BELParser
               name_string,
               value_node.string_literal,
               dataset.identifier,
-              rr)
+              reader)
           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
+          hash[name_string]
         end
 
-        def self.map_value(ast_node, name_string, value_string, identifier, rr)
+        def self.map_value(ast_node, name_string, value_string, identifier, reader)
           value_string = unquote(value_string)
-          value = rr.retrieve_value_from_resource(identifier, value_string)
+          value = reader.retrieve_value_from_resource(identifier, value_string)
           UndefinedAnnotationValueWarning.new(
             ast_node,
             name_string,

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

@@ -1,7 +1,6 @@
 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'
 
@@ -10,20 +9,28 @@ module BELParser
     module Syntax
       class UnresolvableNamespace
         extend BELParser::Language::Syntax::SyntaxFunction
-        extend BELParser::Quoting
 
         TARGET_NODE = BELParser::Parsers::AST::NamespaceDefinition
 
         def self.map(ast_node, script_context)
           return nil unless ast_node.is_a?(TARGET_NODE)
-          resource_reader = script_context[:resource_reader]
+          uri_reader, url_reader = script_context.values_at(:uri_reader, :url_reader)
 
           keyword, domain = ast_node.children
           if domain.url?
-            url = unquote(domain.child.string.string_literal)
-            unless resource_reader.retrieve_resource(url)
-              prefix = keyword.identifier.string_literal
-              return UnresolvableNamespaceError.new(ast_node, prefix, url)
+            ApplyResourceURI.new.process(ast_node)
+            if ast_node.uri
+              uri = ast_node.uri
+              unless uri_reader.retrieve_resource(uri)
+                prefix = keyword.identifier.string_literal
+                return UnresolvableNamespaceError.new(ast_node, prefix, uri)
+              end
+            else
+              url = domain.child.string.string_literal
+              unless url_reader.retrieve_resource(url)
+                prefix = keyword.identifier.string_literal
+                return UnresolvableNamespaceError.new(ast_node, prefix, url)
+              end
             end
           end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bel_parser
 version: !ruby/object:Gem::Version
-  version: 1.0.0.alpha.44
+  version: 1.0.0.alpha.45
 platform: ruby
 authors:
 - Anthony Bargnesi
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-23 00:00:00.000000000 Z
+date: 2016-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sparql-client
@@ -350,6 +350,7 @@ files:
 - lib/bel_parser/resource/sparql_reader.rb
 - lib/bel_parser/resource/value.rb
 - lib/bel_parser/script.rb
+- lib/bel_parser/script/apply_resource_uri.rb
 - lib/bel_parser/script/filter.rb
 - lib/bel_parser/script/first_node.rb
 - lib/bel_parser/script/keywords.rb