bel_parser 1.0.0.alpha.27-java

data/lib/bel_parser/resource/resource_url_reader.rb

@@ -0,0 +1,181 @@
+require          'base64'
+require          'digest'
+require          'dbm'
+require          'net/http'
+require          'tempfile'
+require          'uri'
+require_relative 'reader'
+require_relative 'file_resource'
+require_relative 'file_resource_value'
+
+module BELParser
+  module Resource
+    # ResourceURLReader retrieves {Dataset datasets} and {Value values} from
+    # Annotation (i.e. belanno extension) and Namespace (i.e. belns extension)
+    # files. Value and encoding are stored in DBM database files to reduce the
+    # runtime memory usage (22 resources loaded, totaling 100MB memory usage).
+    #
+    # Only supports resource identifiers with an HTTP or HTTPS scheme.
+    class ResourceURLReader
+      include Reader
+
+      # Class ivars for tracking open {DBM} databases.
+      @dataset_file   = nil
+      @resource_files = {}
+
+      DEFAULT_RESOURCE_VALUE_DELIMITER = '|'
+      private_constant :DEFAULT_RESOURCE_VALUE_DELIMITER
+
+      # Initializes a {ResourceURLReader}.
+      #
+      # @param [Boolean] reuse_database_files specify +true+ to reuse database
+      #        files; +false+ to create new database files (default)
+      def initialize(reuse_database_files = false)
+        @resources = {}
+        @datasets  = ResourceURLReader.open_datasets_file
+        @reuse     = reuse_database_files
+      end
+
+      # Retrieve the resource identified by +resource_identifier+.
+      #
+      # @param  [String] resource_identifier the resource identifier
+      # @return [FileResource] the file resource
+      def retrieve_resource(resource_identifier)
+        read_resource(resource_identifier)[:dataset]
+      end
+
+      def retrieve_value_from_resource(resource_identifier, value)
+        resource = read_resource(resource_identifier)
+        encoding = resource[:values][value]
+        return nil unless encoding
+        FileResourceValue.new(resource[:dataset], value, encoding)
+      end
+
+      def retrieve_values_from_resource(resource_identifier)
+        resource = read_resource(resource_identifier)
+        dataset  = resource[:dataset]
+        resource[:values].lazy.map do |value, encoding|
+          FileResourceValue.new(dataset, value, encoding)
+        end
+      end
+
+      protected
+
+      def read_resource(url)
+        # return cached resource if present
+        resource = @resources[url]
+        return resource if resource
+
+        # read url
+        content = http_get(url)
+        unless content
+          # cache and return empty resource if not resolvable
+          return @resources[url] = empty_resource
+        end
+
+        @resources[url] = create_resource(url, content.each_line)
+      end
+
+      def create_resource(url, line_enum)
+        delimiter           = DEFAULT_RESOURCE_VALUE_DELIMITER
+        dataset             = @datasets[url]
+        values              = ResourceURLReader.open_resource_file(url)
+
+        if @reuse && dataset && values.size > 0
+          warn(
+            <<-MSG.gsub(/^ {14}/, '')
+              Warning - Reusing value database.
+                URL:  #{url}
+                File: #{ResourceURLReader._temporary_resource_file(url)}
+            MSG
+          )
+          return {
+            dataset: FileResource.new(url, *dataset.split('//')),
+            values:  values
+          }
+        end
+
+        value_section               = false
+        type, name, keyword, domain = nil
+        line_enum.each do |line|
+          line.strip!
+          case
+          when line =~ /^#{Regexp.escape('[AnnotationDefinition]')}/
+            type = Dataset::ANNOTATION
+          when line =~ /^#{Regexp.escape('[Namespace]')}/
+            type = Dataset::NAMESPACE
+          when line =~ /^NameString *= *(.*)$/
+            name = Regexp.last_match[1]
+          when line =~ /^Keyword *= *(.*)$/
+            keyword = Regexp.last_match[1]
+          when line =~ /^DomainString *= *(.*)$/
+            domain = Regexp.last_match[1]
+          when line =~ /^DelimiterString *=(.*)$/
+            delimiter = Regexp.last_match[1]
+          when line =~ /^#{Regexp.escape('[Values]')}/
+            dataset = FileResource.new(url, domain, keyword, name, type)
+            value_section = true
+          when value_section
+            value, encoding    = line.strip.split(delimiter)
+            values[value.to_s] = encoding.to_s
+          end
+        end
+
+        resource = {
+          dataset: FileResource.new(url, domain, keyword, name, type),
+          values:  values
+        }
+        @datasets[url] = [domain, keyword, name, type].join('//')
+        resource
+      end
+
+      def empty_resource
+        { dataset: nil, values: {} }
+      end
+
+      def http_get(url)
+        begin
+          _get(URI.parse(url))
+        rescue URI::InvalidURIError, SocketError
+          return nil
+        end
+      end
+
+      def self.open_datasets_file
+        @dataset_file ||= ::DBM.open(_temporary_datasets_file)
+      end
+
+      def self.open_resource_file(url)
+        @resource_files[url] ||= ::DBM.open(_temporary_resource_file(url))
+      end
+
+      def self._temporary_datasets_file
+        resource_directory = File.join(Dir.tmpdir, 'belresources')
+        FileUtils.mkdir_p(resource_directory)
+        File.join(resource_directory, 'datasets.gdbm')
+      end
+
+      def self._temporary_resource_file(url)
+        resource_directory = File.join(Dir.tmpdir, 'belresources')
+        FileUtils.mkdir_p(resource_directory)
+        File.join(resource_directory, "#{_hash_url(url)}.gdbm")
+      end
+
+      def self._hash_url(url)
+        Base64.encode64(Digest::SHA1.digest(url)).delete("/=\n")
+      end
+      private_class_method :_hash_url
+
+      private
+
+      def _get(url, &block)
+        Net::HTTP.start(url.host, url.port) do |http|
+          http.request(Net::HTTP::Get.new(url)) do |response|
+            return response.read_body
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/bel_parser/resource/sparql_reader.rb

@@ -0,0 +1,179 @@
+require 'erb'
+require 'net/http'
+require 'sparql/client'
+require 'uri'
+
+require_relative 'reader'
+require_relative 'lru_reader'
+require_relative 'concept'
+require_relative 'concept_scheme'
+
+module BELParser
+  module Resource
+    # SPARQLReader
+    class SPARQLReader
+      include Reader
+      prepend LRUReader
+
+      SCHEMES      = [URI::HTTP, URI::HTTPS].freeze
+      ALLOW_HEADER = 'Allow'.freeze
+
+      def initialize(sparql_endpoint_url, validate_url = true)
+        validate_sparql_endpoint_url(sparql_endpoint_url) if validate_url
+        @sparql_repository = SPARQL::Client.new(sparql_endpoint_url)
+      end
+
+      def retrieve_resource(resource_identifier)
+        uri              = URI(resource_identifier.to_s)
+        template_binding = binding
+        sparql_query     = RESOLVE_CONCEPT_SCHEME.result(template_binding)
+        hash_to_concept_scheme(resource_identifier,
+          execute_select(sparql_query).first)
+      end
+
+      def retrieve_value_from_resource(resource_identifier, value)
+        uri              = URI(resource_identifier.to_s)
+        template_binding = binding
+        sparql_query     = RESOLVE_CONCEPT.result(template_binding)
+        concept_scheme   = retrieve_resource(resource_identifier)
+        to_concept       = method(:hash_to_concept).to_proc.curry[concept_scheme]
+
+        execute_select(sparql_query).map(&to_concept)
+      end
+
+      def retrieve_values_from_resource(resource_identifier)
+        uri              = URI(resource_identifier.to_s)
+        template_binding = binding
+        sparql_query     = RESOLVE_CONCEPTS.result(template_binding)
+        concept_scheme   = retrieve_resource(resource_identifier)
+        to_concept       = method(:hash_to_concept).to_proc.curry[concept_scheme]
+
+        execute_select(sparql_query).map(&to_concept)
+      end
+
+      protected
+
+      def execute_select(sparql_query)
+        @sparql_repository.query(sparql_query).map do |solution|
+          solution.to_hash
+        end
+      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
+
+      def hash_to_concept(concept_scheme, hash)
+        Concept.new(concept_scheme, 
+          *hash.values_at(:concept, :prefLabel, :identifier, :title,
+            :altLabels, :types))
+      end
+
+      def validate_sparql_endpoint_url(url)
+        url_s = url.to_s
+        scheme, host, port = URI(url_s).select(:scheme, :host, :port)
+        validate_uri_scheme(scheme, url_s)
+
+        options_request  = Net::HTTP::Options.new(url_s)
+        options_response = Net::HTTP.start(host, port) do |http|
+          http.request(Net::HTTP::Options.new(url_s))
+        end
+        validate_200(options_response, url_s)
+        validate_allowed_methods(options_response, url_s)
+      end
+
+      def validate_uri_scheme(scheme, url_s)
+        unless SCHEMES.include?(URI.scheme_list[scheme.upcase])
+          raise ArgumentError,
+            "expected HTTP or HTTPS scheme for url: #{url_s}"
+        end
+      end
+
+      def validate_200(response, url_s)
+        unless response.code_type == Net::HTTPOK
+          raise ArgumentError,
+            <<-MSG.gsub(/ {14}/, '').delete("\n")
+              expected URL to respond 200 (received #{response.code}) for 
+              OPTIONS request to: #{url_s}"
+            MSG
+        end
+      end
+
+      def validate_allowed_methods(response, url_s)
+        unless response[ALLOW_HEADER].to_s =~ /GET|POST/
+          raise ArgumentError,
+            "expected URL to allow GET or POST: #{url_s}"
+        end
+      end
+
+      RESOLVE_CONCEPT_SCHEME = ERB.new(<<-SPARQL)
+        prefix belv: <http://www.openbel.org/vocabulary/>
+        prefix dct:  <http://purl.org/dc/terms/>
+        prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+        prefix skos: <http://www.w3.org/2004/02/skos/core#>
+        select ?domain ?prefix ?prefLabel (group_concat(?type;separator='|') as ?types)
+        where {
+            <<%= uri %>> rdf:type       skos:ConceptScheme .
+            <<%= uri %>> rdf:type       ?type .
+            <<%= uri %>> belv:domain    ?domain .
+            <<%= uri %>> belv:prefix    ?prefix .
+            <<%= uri %>> skos:prefLabel ?prefLabel .
+        }
+        group by ?domain ?prefix ?prefLabel
+      SPARQL
+
+      RESOLVE_CONCEPT = ERB.new(<<-SPARQL)
+        prefix belv: <http://www.openbel.org/vocabulary/>
+        prefix dct:  <http://purl.org/dc/terms/>
+        prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+        prefix skos: <http://www.w3.org/2004/02/skos/core#>
+        select ?concept ?prefLabel ?identifier ?title
+          (group_concat(distinct(?type);separator='|') as ?types)
+          (group_concat(distinct(?altLabel);separator='|') as ?altLabels)
+        where {
+            {?concept    skos:prefLabel "<%= value %>"}
+              UNION
+            {?concept    dct:identifier "<%= value %>"}
+              UNION
+            {?concept    dct:title      "<%= value %>"}
+              UNION
+            {?concept    skos:altLabel  "<%= value %>"}
+
+            ?concept     skos:inScheme  <<%= uri %>> .
+            ?concept     rdf:type       ?type .
+
+            ?concept     skos:prefLabel ?prefLabel .
+            ?concept     dct:identifier ?identifier .
+            optional {
+              ?concept     dct:title      ?title .
+              ?concept     skos:altLabel  ?altLabel .
+            }
+        }
+        group by ?concept ?prefLabel ?identifier ?title
+      SPARQL
+
+      RESOLVE_CONCEPTS = ERB.new(<<-SPARQL)
+        prefix belv: <http://www.openbel.org/vocabulary/>
+        prefix dct:  <http://purl.org/dc/terms/>
+        prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+        prefix skos: <http://www.w3.org/2004/02/skos/core#>
+        select ?concept ?prefLabel ?identifier ?title
+          (group_concat(distinct(?type);separator='|') as ?types)
+          (group_concat(distinct(?altLabel);separator='|') as ?altLabels)
+        where {
+            ?concept skos:inScheme  <<%= uri %>> .
+            ?concept rdf:type       ?type .
+            ?concept skos:prefLabel ?prefLabel .
+            optional {
+              ?concept dct:identifier ?identifier .
+              ?concept dct:title      ?title .
+              ?concept skos:altLabel  ?altLabel
+            }
+        }
+        group by ?concept ?prefLabel ?identifier ?title
+      SPARQL
+    end
+  end
+end

data/lib/bel_parser/resource/value.rb

@@ -0,0 +1,31 @@
+module BELParser
+  module Resource
+    # Value
+    module Value
+
+      def dataset
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+
+      def name
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+
+      def identifier
+        nil
+      end
+
+      def title
+        nil
+      end
+
+      def synonyms
+        []
+      end
+
+      def encodings
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+    end
+  end
+end

data/lib/bel_parser/script.rb

@@ -0,0 +1,8 @@
+require_relative 'script/keywords'
+require_relative 'script/state_function'
+
+require_relative 'script/filter'
+require_relative 'script/first_node'
+require_relative 'script/state_aggregator'
+require_relative 'script/validator'
+require_relative 'script/nanopub_mapper'

data/lib/bel_parser/script/filter.rb

@@ -0,0 +1,35 @@
+module BELParser
+  module Script
+    # Filter will enumerate {BELParser::Parsers::AST::Node AST nodes} that are
+    # relevant to lines in a BEL Script document. It selects the relevant nodes
+    # from an {BELParser::Parsers::AST::Node AST node} enumerator.
+    class Filter
+      # Represents the BEL Script AST Node type.
+      # TODO These could be AST::Node subclasses instead.
+      TYPES = [
+        :simple_statement,
+        :observed_term,
+        :nested_statement,
+        :annotation_definition,
+        :namespace_definition,
+        :set,
+        :document_property,
+        :unset,
+        :blank_line,
+        :comment_line
+      ]
+
+      def initialize(ast_enum)
+        @ast_filter = BELParser::ASTFilter.new(ast_enum, *TYPES)
+      end
+
+      def each(&block)
+        if block_given?
+          @ast_filter.each(&block)
+        else
+          enum_for(:each)
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/script/first_node.rb

@@ -0,0 +1,21 @@
+module BELParser
+  module Script
+    # FirstNode will return the first node from the set of
+    # {BELParser::Parsers::AST::Node AST nodes} provided.
+    class FirstNode
+      def initialize(ast_enum)
+        @ast_enum = ast_enum
+      end
+
+      def each
+        if block_given?
+          @ast_enum.each do |(line_number, line, ast_nodes)|
+            yield [line_number, line, ast_nodes.first]
+          end
+        else
+          enum_for(:each)
+        end
+      end
+    end
+  end
+end