bel_parser 1.0.0.alpha.27-java

data/lib/bel_parser/quoting.rb

@@ -0,0 +1,177 @@
+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.
+  #
+  # A value can either be an identifier or a string value. An
+  # identifier can only include the characters +[0-9A-Za-z_]+. A string
+  # value is necessary when at least one of +[^0-9A-Za-z_]+ exists in
+  # the value.
+  #
+  # Uses:
+  #
+  # BEL: The BEL parameters must be an identifier or string value.
+  #
+  # 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).freeze
+
+    # Regular expression that matches one of {Quoting::Keywords}.
+    KeywordMatcher         = Regexp.compile(/^(#{Keywords.join('|')})$/)
+
+    # Regular expression that matches on any non-word character.
+    NonWordMatcher         = Regexp.compile(/[^0-9a-zA-Z_]/)
+
+    # Regular expression that matches a value surrounded by unescaped
+    # double quotes.
+    StrictQuotedMatcher    = Regexp.compile(/\A".*?(?<!\\)"\Z/m)
+
+    # Regular expression that matches a value surrounded by double quotes
+    # that may be escaped.
+    LenientQuotedMatcher   = Regexp.compile(/\A".*?"\Z/m)
+
+    # Regular expression that matches double quotes that are not escaped.
+    QuoteNotEscapedMatcher = Regexp.compile(/(?<!\\)"/m)
+
+    # Returns +value+ surrounded by double quotes. This method is idempotent
+    # so +value+ will only be quoted once regardless of how may times the
+    # method is called on it.
+    #
+    # @example Quoting a BEL parameter.
+    #    quote("apoptotic process")
+    #    # => "\"apoptotic process\""
+    # @example Escaping quotes within a value.
+    #    quote("vesicle fusion with \"Golgi apparatus\"")
+    #    # => "\"vesicle fusion with \\\"Golgi apparatus\\\"\""
+    #
+    # @parameter [#to_s] value a value to be quoted
+    # @return    [String] value surrounded by double quotes
+    def quote(value)
+      string   = value.to_s
+      unquoted = unquote(string)
+      escaped  = unquoted.gsub(QuoteNotEscapedMatcher, '\\"')
+      %("#{escaped}")
+    end
+
+    # Returns +value+ with surrounded quotes removed.
+    #
+    # @example Unquoting a BEL parameter.
+    #    unquote("\"apoptotic process\"")
+    #    # => "apoptotic process"
+    # @example Escaped quotes are preserved.
+    #    unquote("\"vesicle fusion with \"Golgi apparatus\"\"")
+    #
+    # @parameter [#to_s]  value a value to be unquoted
+    # @return    [String] value with surrounding double quotes removed
+    def unquote(value)
+      string = value.to_s
+      if string =~ StrictQuotedMatcher
+        string[1...-1]
+      else
+        string
+      end
+    end
+
+    # Returns +value+ with quoting applied only if necessary. A +value+
+    # consisting of only word character (e.g. [0-9A-Za-z_]) does not need
+    # quoting. A +value+ consisting of at least one non-word character
+    # (e.g. [^0-9A-Za-z_]) will requiring quoting.
+    #
+    # @example Quotes added when value includes spaces.
+    #    quote_if_needed("apoptotic process")
+    #    # => "\"apoptotic process\""
+    # @example Quotes added when value includes double quote.
+    #    quote_if_needed("vesicle fusion with \"Golgi apparatus\"")
+    #    # => "\"vesicle fusion with \\\"Golgi apparatus\\\"\""
+    # @example No quotes necessary for identifier.
+    #    quote_if_needed("AKT1_HUMAN")
+    #    # => "AKT1_HUMAN"
+    #
+    # @parameter [#to_s]  value that may be quoted
+    # @return    [String] original value or quoted value
+    def quote_if_needed(value)
+      if string_value?(value)
+        quote(value)
+      else
+        value.to_s
+      end
+    end
+
+    # Returns whether the +value+ is surrounded by double quotes.
+    #
+    # @example Returns +true+ when value is quoted.
+    #    quoted?("\"vesicle fusion with \"Golgi apparatus\"")
+    #    # => true
+    # @example Returns +false+ when value is not quoted.
+    #    quoted?("apoptotic process")
+    #    # => false
+    #
+    # @parameter [#to_s]   value to test
+    # @return    [Boolean] +true+ if +value+ is quoted, +false+ if
+    #            +value+ is not quoted
+    def quoted?(value)
+      string = value.to_s
+      (string =~ LenientQuotedMatcher) != nil
+    end
+
+    # Returns whether the +value+ is not surrounded by double quotes.
+    #
+    # @example Returns +true+ when value is not quoted.
+    #    unquoted?("apoptotic process")
+    #    # => true
+    # @example Returns +false+ when value is quoted.
+    #    unquoted?("\"vesicle fusion with \"Golgi apparatus\"")
+    #    # => false
+    #
+    # @parameter [#to_s]   value to test
+    # @return    [Boolean] +true+ if +value+ is not quoted, +false+ if
+    #            +value+ is quoted
+    def unquoted?(value)
+      !quoted?(value)
+    end
+
+    # Returns whether the +value+ represents an identifier. An
+    # identifier consists of only word characters (e.g. [0-9A-Za-z_]).
+    #
+    # @example Returns +true+ when representing an identifier.
+    #    identifier_value?("AKT1_HUMAN")
+    #    # => true
+    # @example Returns +false+ when not representing an identifier.
+    #    identifier_value?("apoptotic process")
+    #    # => false
+    #
+    # @parameter [#to_s]   value to test
+    # @return    [Boolean] +true+ if +value+ is an identifier,
+    #            +false+ if +value+ is not an identifier
+    def identifier_value?(value)
+      string = value.to_s
+      [NonWordMatcher, KeywordMatcher].none? do |matcher|
+        matcher.match string
+      end
+    end
+
+    # Returns whether the +value+ represents a string value. A string
+    # value consists of at least one non-word character
+    # (e.g. [^0-9A-Za-z_]).
+    #
+    # @example Returns +true+ when representing a string value.
+    #    string_value?("apoptotic process")
+    #    # => true
+    # @example Returns +false+ when not representing a string value.
+    #    string_value?("AKT1_HUMAN")
+    #    # => false
+    #
+    # @parameter [#to_s]   value to test
+    # @return    [Boolean] +true+ if +value+ is a string value,
+    #            +false+ if +value+ is not a string value
+    def string_value?(value)
+      string = value.to_s
+      [NonWordMatcher, KeywordMatcher].any? do |matcher|
+        matcher.match string
+      end
+    end
+  end
+end

data/lib/bel_parser/resource/concept.rb

@@ -0,0 +1,56 @@
+require_relative 'value'
+
+module BELParser
+  module Resource
+    # Concept
+    class Concept
+      include Value
+
+      attr_reader :dataset, :uri, :name, :identifier,
+                  :title,   :synonyms, :encodings
+
+      def initialize(dataset, uri, pref_label, identifier,
+                     title,   alt_labels, types)
+
+        @dataset    = dataset
+        @uri        = uri
+        @name       = pref_label.to_s
+        @identifier = identifier.to_s
+        @title      = title.to_s
+        @synonyms   = alt_labels.to_s.split('|')
+        @encodings  = convert_encoding_types(types.to_s)
+      end
+
+      private
+
+      def convert_encoding_types(types)
+        types.split('|').map do |type|
+          case type
+          when /AbundanceConcept$/
+            :A
+          when /BiologicalProcessConcept$/
+            :B
+          when /ComplexConcept$/
+            :C
+          when /GeneConcept$/
+            :G
+          when /LocationConcept$/
+            :L
+          when /MicroRNAConcept$/
+            :M
+          when /MolecularActivityConcept$/
+            :T
+          when /PathologyConcept$/
+            :O
+          when /ProteinConcept$/
+            :P
+          when /ProteinModificationConcept$/
+            :E
+          when /RNAConcept$/
+            :R
+          end
+        end.compact
+      end
+    end
+  end
+end

data/lib/bel_parser/resource/concept_scheme.rb

@@ -0,0 +1,35 @@
+require_relative 'dataset'
+
+module BELParser
+  module Resource
+    #ConceptScheme
+    class ConceptScheme
+      include Dataset
+
+      attr_reader :identifier, :domain, :keyword, :name, :types
+
+      def initialize(identifier, domain, prefix, name, types)
+        @identifier = identifier.to_s
+        @domain     = domain.to_s
+        @keyword    = prefix.to_s
+        @name       = name.to_s
+        @types      = convert_types(types.to_s)
+      end
+
+      private
+
+      def convert_types(types)
+        types.split('|').map do |type|
+          case type
+          when /NamespaceConceptScheme$/
+            Dataset::NAMESPACE
+          when /AnnotationConceptScheme$/
+            Dataset::ANNOTATION
+          else
+            nil
+          end
+        end.compact
+      end
+    end
+  end
+end

data/lib/bel_parser/resource/dataset.rb

@@ -0,0 +1,34 @@
+module BELParser
+  module Resource
+    # Dataset
+    module Dataset
+
+      ANNOTATION = :annotation
+      NAMESPACE  = :namespace
+
+      def identifier
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+
+      def keyword
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+
+      def domain
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+
+      def annotation_resource?
+        types.include?(ANNOTATION)
+      end
+
+      def namespace_resource?
+        types.include?(NAMESPACE)
+      end
+
+      def types
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+    end
+  end
+end

data/lib/bel_parser/resource/eager_reader.rb

@@ -0,0 +1,89 @@
+require 'concurrent/hash'
+
+module BELParser
+  module Resource
+    module EagerReader
+
+      EMPTY_ARRAY = [].freeze
+      CACHE_KEYS  = [:name, :identifier, :title, :synonyms].freeze
+
+      def resources
+        @resources ||= Concurrent::Hash.new
+      end
+
+      def locks
+        @locks ||= Concurrent::Hash.new
+      end
+
+      def load_threads
+        @load_threads ||= Concurrent::Hash.new
+      end
+
+      def load_values(identifier)
+        lock = locks[identifier] ||= Mutex.new
+        if identifier.include?('taxonomy')
+          puts "load_all_values, try lock..."
+            end
+        if lock.try_lock
+          load_threads[identifier] = Thread.new do
+            value_hash = {
+              :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
+              concept.synonyms.each do |synonym|
+                value_hash[:synonyms][synonym] = concept
+              end
+            end
+            resources[identifier] = value_hash
+            lock.unlock
+          end
+        end
+      end
+
+      def retrieve_resource(resource_identifier)
+        if !resources.key?(resource_identifier)
+          load_all_values(resource_identifier)
+        end
+      end
+
+      def retrieve_value_from_resource(resource_identifier, value)
+        if !resources.key?(resource_identifier)
+          load_all_values(resource_identifier)
+          if load_threads.key?(resource_identifier)
+            load_thread = load_threads[resource_identifier]
+            load_thread.join unless load_thread == Thread.current
+          end
+        end
+
+        concepts = resources[resource_identifier]
+        return nil unless concepts
+        CACHE_KEYS.each do |key|
+          cached_concept = concepts[key].fetch(value, nil)
+          return cached_concept if cached_concept
+        end
+        nil
+      end
+
+      def retrieve_values_from_resource(resource_identifier)
+        if !resources.key?(resource_identifier)
+          load_all_values(resource_identifier)
+          if load_threads.key?(resource_identifier)
+            load_thread = load_threads[resource_identifier]
+            load_thread.join unless load_thread == Thread.current
+          end
+        end
+
+        concepts = resources[resource_identifier]
+        return nil unless concepts
+        concepts[:name].values
+      end
+
+    end
+  end
+end

data/lib/bel_parser/resource/eager_sparql_reader.rb

@@ -0,0 +1,51 @@
+require 'concurrent/hash'
+
+require_relative 'sparql_reader'
+
+module BELParser
+  module Resource
+    # EagerSPARQLReader
+    class EagerSPARQLReader < SPARQLReader
+      def initialize(sparql_endpoint_url, validate_url = true)
+        @resources = Concurrent::Hash.new
+        @locks     = Concurrent::Hash.new
+        super
+      end
+
+      def retrieve_resource(resource_identifier)
+        if @resources.key?(resource_identifier)
+          concepts = @resources[resource_identifier]
+          concepts[value]
+        else
+          lock = @locks[resource_identifier] ||= Mutex.new
+          if lock.try_lock
+            Thread.new do
+              concepts = retrieve_values_from_resource(resource_identifier).to_a
+              @resources[resource_identifier] = 
+                Hash[
+                  concepts.map do |c|
+                    [c.name, c]
+                  end
+                ]
+              lock.unlock
+            end
+          end
+
+          super
+        end
+      end
+
+      def retrieve_value_from_resource(resource_identifier, value)
+        concepts = @resources[resource_identifier]
+        return super unless concepts
+        concepts[value]
+      end
+
+      def retrieve_values_from_resource(resource_identifier)
+        concepts = @resources[resource_identifier]
+        return super unless concepts
+        concepts
+      end
+    end
+  end
+end