bel_parser 1.0.0.alpha.27-java

data/lib/bel_parser/resource/file_resource.rb

@@ -0,0 +1,21 @@
+require_relative 'dataset'
+
+# FileResource is a {Dataset} description obtained from a Annotation or
+# Namespace file.
+module BELParser
+  module Resource
+    class FileResource
+      include Dataset
+
+      attr_reader :identifier, :domain, :keyword, :name, :types
+
+      def initialize(identifier, domain, keyword, name, type)
+        @identifier = identifier.to_s
+        @domain     = domain.to_s
+        @keyword    = keyword.to_s
+        @name       = name.to_s
+        @types      = [type]
+      end
+    end
+  end
+end

data/lib/bel_parser/resource/file_resource_value.rb

@@ -0,0 +1,24 @@
+require_relative 'value'
+
+# FileResourceValue is a {Value} obtained from a Annotation or Namespace
+# file.
+module BELParser
+  module Resource
+    class FileResourceValue
+      include Value
+
+      attr_reader :dataset, :name, :encodings
+
+      def initialize(dataset, name, encodings)
+        @dataset   = dataset
+        @name      = name
+        @encodings =
+          if dataset.annotation_resource? && !dataset.namespace_resource?
+            nil
+          else
+            encodings.chars.map(&:to_sym)
+          end
+      end
+    end
+  end
+end

data/lib/bel_parser/resource/jena_tdb_reader.rb

@@ -0,0 +1,246 @@
+require 'erb'
+require 'rdf'
+require 'rdf/vocab'
+require 'rdf/jena'
+
+require_relative 'reader'
+require_relative 'lru_reader'
+require_relative 'concept'
+require_relative 'concept_scheme'
+
+module BELParser
+  module Resource
+    class JenaTDBReader
+      include Reader
+      prepend LRUReader
+
+      BELV = RDF::Vocabulary.new('http://www.openbel.org/vocabulary/')
+      SKOS = RDF::Vocab::SKOS
+      DC   = RDF::Vocab::DC
+      VALUE_PREDICATE_ORDER = [
+        SKOS.prefLabel,
+        DC.identifier,
+        DC.title,
+        SKOS.altLabel
+      ]
+
+      def initialize(tdb_directory_path)
+        @rdf = RDF::Jena::Repository.new(tdb_directory_path)
+      end
+
+      def retrieve_resource(identifier)
+        uri   = RDF::URI(identifier)
+        domain, prefix, pref_label = nil
+        types                      = []
+        @rdf.query([:subject => uri]).each do |solution|
+          case solution.predicate
+          when RDF.type
+            types << solution.object
+          when BELV.domain
+            domain = solution.object.to_s
+          when BELV.prefix
+            prefix = solution.object.to_s
+          when SKOS.prefLabel
+            pref_label = solution.object.to_s
+          end
+        end
+        return nil unless types.any? do |type_uri|
+          type_uri == BELV.AnnotationConceptScheme || type_uri == BELV.NamespaceConceptScheme
+        end
+        ConceptScheme.new(uri, domain, prefix, pref_label, types)
+      end
+
+      def retrieve_value_from_resource(identifier, value)
+        concept_scheme = retrieve_resource(identifier)
+        return nil unless concept_scheme
+
+        template_binding = binding
+        sparql_query     = RESOLVE_CONCEPT.result(template_binding)
+        to_concept       = method(:hash_to_concept).to_proc.curry[concept_scheme]
+
+        @rdf.query_execute(sparql_query).map(&to_concept)
+      end
+
+      def retrieve_values_from_resource(identifier)
+        concept_scheme = retrieve_resource(identifier)
+        return nil unless concept_scheme
+
+        template_binding = binding
+        sparql_query     = RESOLVE_CONCEPTS.result(template_binding)
+        to_concept       = method(:hash_to_concept).to_proc.curry[concept_scheme]
+
+        @rdf.query_execute(sparql_query).map(&to_concept)
+      end
+
+      private
+
+      def find_value_uris(resource_uri, value)
+        VALUE_PREDICATE_ORDER.each do |predicate|
+          subjects =
+            @rdf.query([:predicate => predicate, :object => value])
+            .select do |stmt|
+              @rdf.has_statement?(
+                RDF::Statement(stmt.subject, SKOS.inScheme, resource_uri))
+            end.map(&:subject)
+
+          if !subjects.empty?
+            return subjects
+          end
+        end
+
+        []
+      end
+
+      def hash_to_concept(concept_scheme, hash)
+        Concept.new(concept_scheme, 
+          *hash.values_at('concept', 'prefLabel', 'identifier', 'title',
+            'altLabels', 'types'))
+      end
+
+      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  <<%= identifier %>> .
+            ?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  <<%= identifier %>> .
+            ?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
+
+      #ConceptScheme
+      class ConceptScheme
+        include Dataset
+
+        attr_reader :identifier, :domain, :keyword, :name, :types
+
+        def initialize(uri, domain, prefix, name, types)
+          @identifier = uri
+          @domain     = domain.to_s
+          @keyword    = prefix.to_s
+          @name       = name.to_s
+          @types      = convert_types(types)
+        end
+
+        private
+
+        def convert_types(types)
+          types.map do |type|
+            case type
+            when BELV.NamespaceConceptScheme
+              Dataset::NAMESPACE
+            when BELV.AnnotationConceptScheme
+              Dataset::ANNOTATION
+            end
+          end.compact
+        end
+      end
+
+      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   =
+            if alt_labels.respond_to?(:each)
+              alt_labels.map(&:to_s)
+            else
+              alt_labels.to_s.split('|')
+            end
+          @encodings  =
+            if types.respond_to?(:each)
+              convert_encoding_types(types.map(&:to_s))
+            else
+              convert_encoding_types(types.to_s.split('|'))
+            end
+        end
+
+        private
+
+        def convert_encoding_types(types)
+          types.map do |type|
+            case type
+            when BELV.AbundanceConcept
+              :A
+            when BELV.BiologicalProcessConcept
+              :B
+            when BELV.ComplexConcept
+              :C
+            when BELV.GeneConcept
+              :G
+            when BELV.LocationConcept
+              :L
+            when BELV.MicroRNAConcept
+              :M
+            when BELV.MolecularActivityConcept
+              :T
+            when BELV.PathologyConcept
+              :O
+            when BELV.ProteinConcept
+              :P
+            when BELV.ProteinModificationConcept
+              :E
+            when BELV.RNAConcept
+              :R
+            end
+          end.compact
+        end
+      end
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  reader = BELParser::Resource::JenaTDBReader.new(
+    '/home/tony/projects/openbel/resource-reasoner/biological-concepts-db')
+  reader.retrieve_resource('http://www.openbel.org/bel/namespace/hgnc-human-genes')
+end

data/lib/bel_parser/resource/lru_cache.rb

@@ -0,0 +1,111 @@
+require 'concurrent/hash'
+
+module BELParser
+  module Resource
+    # LRUCache implements a least recently used cache. This implementation was
+    # adapted from https://github.com/SamSaffron/lru_redux.
+		class LRUCache
+			def initialize(max_size)
+				raise ArgumentError.new(:max_size) if max_size < 1
+
+				@max_size = max_size
+				@data = Concurrent::Hash.new
+			end
+
+			def max_size=(max_size)
+				max_size ||= @max_size
+
+				raise ArgumentError.new(:max_size) if max_size < 1
+
+				@max_size = max_size
+
+				@data.shift while @data.size > @max_size
+			end
+
+			def getset(key)
+				found = true
+				value = @data.delete(key){ found = false }
+				if found
+					@data[key] = value
+				else
+					result = @data[key] = yield
+					@data.shift if @data.length > @max_size
+					result
+				end
+			end
+
+			def fetch(key)
+				found = true
+				value = @data.delete(key){ found = false }
+				if found
+					@data[key] = value
+				else
+					yield if block_given?
+				end
+			end
+
+			def [](key)
+				found = true
+				value = @data.delete(key){ found = false }
+				if found
+					@data[key] = value
+				else
+					nil
+				end
+			end
+
+			def []=(key,val)
+				@data.delete(key)
+				@data[key] = val
+				@data.shift if @data.length > @max_size
+				val
+			end
+
+			def each
+				unless block_given?
+					return enum_for(:each)
+				end
+
+				array = @data.to_a
+				array.reverse!.each do |pair|
+					yield pair
+				end
+			end
+
+			# used further up the chain, non thread safe each
+			alias_method :each_unsafe, :each
+
+			def to_a
+				array = @data.to_a
+				array.reverse!
+			end
+
+			def delete(key)
+				@data.delete(key)
+			end
+
+			alias_method :evict, :delete
+
+			def key?(key)
+				@data.key?(key)
+			end
+
+			alias_method :has_key?, :key?
+
+			def clear
+				@data.clear
+			end
+
+			def count
+				@data.size
+			end
+
+			protected
+
+			# for cache validation only, ensures all is sound
+			def valid?
+				true
+			end
+		end
+	end
+end

data/lib/bel_parser/resource/lru_reader.rb

@@ -0,0 +1,34 @@
+require_relative 'lru_cache'
+
+module BELParser
+  module Resource
+    module LRUReader
+
+      LRU_MAX_SIZE = 2000
+      private_constant :LRU_MAX_SIZE
+
+      def retrieve_resource(resource_identifier)
+        @resources ||= Hash.new { |hash, key| hash[key] = {} }
+        cached_dataset = @resources[resource_identifier][:dataset]
+        return cached_dataset if cached_dataset
+
+        resolved_dataset = super
+        @resources[resource_identifier][:dataset] = resolved_dataset
+        @resources[resource_identifier][:values]  = LRUCache.new(LRU_MAX_SIZE)
+        resolved_dataset
+      end
+
+      def retrieve_value_from_resource(resource_identifier, value)
+        retrieve_resource(resource_identifier)
+        @resources[resource_identifier][:values].getset(value) {
+          super
+        }
+      end
+
+      def retrieve_values_from_resource(resource_identifier)
+        retrieve_resource(resource_identifier)
+        super
+      end
+    end
+  end
+end

data/lib/bel_parser/resource/reader.rb

@@ -0,0 +1,18 @@
+module BELParser
+  module Resource
+    # Reader represents the API for a reader of resource data.
+    module Reader
+      def retrieve_resource(resource_identifier)
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+
+      def retrieve_value_from_resource(resource_identifier, value)
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+
+      def retrieve_values_from_resource(resource_identifier)
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+    end
+  end
+end