bel 0.3.3 → 0.4.0.beta1

data/lib/bel/resource/namespace.rb

@@ -0,0 +1,122 @@
+require_relative '../resource'
+require_relative 'namespace_value'
+
+module BEL
+  module Resource
+
+    # TODO Document
+    class Namespace
+
+      attr_reader :uri
+
+      # TODO Document
+      def initialize(rdf_repository, uri)
+        @rdf_repository = rdf_repository
+        @uri            = uri
+        @uri_hash       = uri.hash
+        @concept_query  = [
+          :predicate => RDF::SKOS.inScheme,
+          :object    => uri
+        ]
+        @predicates     = @rdf_repository.query(:subject => uri).
+                            each.map(&:predicate)
+      end
+
+      # TODO Document
+      def each
+        return to_enum(:each) unless block_given?
+				@rdf_repository.
+					query(@concept_query) { |solution|
+						yield NamespaceValue.new(@rdf_repository, solution.subject)
+					}
+      end
+
+      def find(*values)
+        return to_enum(:find, *values) unless block_given?
+
+        values.flatten.each do |v|
+          yield find_value(v)
+				end
+			end
+
+      def hash
+        @uri_hash
+      end
+
+      def ==(other)
+        return false if other == nil
+        @uri == other.uri
+      end
+      alias_method :eql?, :'=='
+
+      protected
+
+      def find_value(value)
+        # nil input always yield nil
+        return nil if value == nil
+
+        # RDF::URI input handled as a special case
+        return find_namespace_value_uri(value) if value.is_a?(RDF::URI)
+
+        # input handled as literal identifier; empty literals match in a
+        # pattern as if it was nil so return nil if empty string
+        vstr  = value.to_s
+        return nil if vstr.empty?
+
+        # match input as namespace value prefLabel
+				vlit  = RDF::Literal(vstr)
+				label = value_query(
+					:predicate => RDF::SKOS.prefLabel,
+					:object    => vlit
+				)
+			  return NamespaceValue.new(@rdf_repository, label.subject) if label
+
+        # match input as namespace value identifier
+				ident = value_query(
+					:predicate => RDF::DC.identifier,
+					:object    => vlit
+				)
+				return NamespaceValue.new(@rdf_repository, ident.subject) if ident
+
+        # match input as namespace value title
+				title = value_query(
+					:predicate => RDF::DC.title,
+					:object    => vlit
+				)
+				return NamespaceValue.new(@rdf_repository, title.subject) if title
+      end
+
+      def find_namespace_value_uri(uri)
+        in_namespace_check = @rdf_repository.has_statement?(
+          RDF::Statement(uri, RDF::SKOS.inScheme, @uri)
+        )
+        return nil if !in_namespace_check
+
+        type_check = RDF::Statement(uri, RDF.type, BELV.NamespaceConcept)
+				if @rdf_repository.has_statement?(type_check)
+          return NamespaceValue.new(@rdf_repository, uri)
+        end
+			end
+
+      def value_query(pattern)
+				@rdf_repository.query(pattern).find { |solution|
+				  @rdf_repository.has_statement?(
+						RDF::Statement(solution.subject, RDF::SKOS.inScheme, @uri)
+					)
+				}
+      end
+
+      def method_missing(method)
+        method_predicate = @predicates.find { |p|
+          p.qname[1].to_sym == method.to_sym
+        }
+        return nil unless method_predicate
+        objects = @rdf_repository.query(
+          :subject   => @uri,
+          :predicate => method_predicate
+        ).each.map(&:object)
+        objects.size == 1 ? objects.first : objects.to_a
+      end
+    end
+  end
+end

data/lib/bel/resource/namespace_value.rb

@@ -0,0 +1,69 @@
+require_relative '../resource'
+
+module BEL
+  module Resource
+
+    # TODO Document
+    class NamespaceValue
+
+      attr_reader :uri
+
+      # TODO Document
+      def initialize(rdf_repository, uri)
+        @rdf_repository = rdf_repository
+        @uri            = uri
+        @uri_hash       = uri.hash
+        @eq_query       = [
+          :subject   => uri,
+          :predicate => RDF::SKOS.exactMatch
+        ]
+        @ortho_query    = [
+          :subject   => uri,
+          :predicate => BELV.orthologousMatch
+        ]
+        @predicates     = @rdf_repository.query(:subject => uri).
+                            each.map(&:predicate).uniq
+      end
+
+      def equivalents
+        return to_enum(:equivalents) unless block_given?
+				@rdf_repository.
+					query(@eq_query) { |solution|
+						yield NamespaceValue.new(@rdf_repository, solution.object)
+					}
+			end
+
+      def orthologs
+        return to_enum(:orthologs) unless block_given?
+				@rdf_repository.
+					query(@ortho_query) { |solution|
+						yield NamespaceValue.new(@rdf_repository, solution.object)
+					}
+			end
+
+      def hash
+        @uri_hash
+      end
+
+      def ==(other)
+        return false if other == nil
+        @uri == other.uri
+      end
+      alias_method :eql?, :'=='
+
+      protected
+
+      def method_missing(method)
+        method_predicate = @predicates.find { |p|
+          p.qname[1].to_sym == method.to_sym
+        }
+        return nil unless method_predicate
+        objects = @rdf_repository.query(
+          :subject   => @uri,
+          :predicate => method_predicate
+        ).each.map(&:object)
+        objects.size == 1 ? objects.first : objects.to_a
+      end
+    end
+  end
+end

data/lib/bel/resource/namespaces.rb

@@ -0,0 +1,83 @@
+require_relative '../resource'
+require_relative 'namespace'
+
+module BEL
+  module Resource
+
+    # TODO Document
+    class Namespaces
+
+      # TODO Document
+      QUERY_NAMESPACES = RDF::Query.new do
+        pattern [:uri, RDF.type, BELV.NamespaceConceptScheme]
+      end
+
+      # TODO Document
+      def initialize(rdf_repository)
+        @rdf_repository = rdf_repository
+      end
+
+      # TODO Document
+      def each
+        return to_enum(:each) unless block_given?
+				@rdf_repository.
+					query(QUERY_NAMESPACES) { |solution|
+						yield Namespace.new(@rdf_repository, solution.uri)
+					}
+      end
+
+      def find(*namespaces)
+        return to_enum(:find, *namespaces) unless block_given?
+
+        namespaces.flatten.each do |ns|
+          yield find_namespace(ns)
+				end
+			end
+
+      protected
+
+      def find_namespace(namespace)
+        # nil input always yield nil
+        return nil if namespace == nil
+
+        # RDF::URI input handled as a special case
+        return find_namespace_uri(namespace) if namespace.is_a?(RDF::URI)
+
+        # input handled as literal identifier; empty literals will match
+        # in a pattern as if it was nil so return nil if empty string
+        nstr  = namespace.to_s
+        return nil if nstr.empty?
+
+        # match input as namespace prefix
+				nlit   = RDF::Literal(nstr)
+				prefix = namespace_query(
+					:predicate => BELV.prefix,
+					:object    => nlit
+				)
+			  return Namespace.new(@rdf_repository, prefix.subject) if prefix
+
+        # match input as namespace prefLabel
+				label  = namespace_query(
+					:predicate => RDF::SKOS.prefLabel,
+					:object    => nlit
+				)
+				return Namespace.new(@rdf_repository, label.subject) if label
+      end
+
+      def find_namespace_uri(uri)
+        type_check = RDF::Statement(uri, RDF.type, BELV.NamespaceConceptScheme)
+				if @rdf_repository.has_statement?(type_check)
+          return Namespace.new(@rdf_repository, uri)
+        end
+			end
+
+      def namespace_query(pattern)
+				@rdf_repository.query(pattern).find { |solution|
+				  @rdf_repository.has_statement?(
+						RDF::Statement(solution.subject, RDF.type, BELV.NamespaceConceptScheme)
+					)
+				}
+      end
+    end
+  end
+end

data/lib/bel/resource/search.rb

@@ -0,0 +1,26 @@
+require_relative 'search/search_result'
+require_relative 'search/api'
+
+module BEL
+  module Resource
+
+    module Search
+
+      module Plugins; end
+
+      extend LittlePlugger(
+        :path   => 'bel/resource/search/plugins',
+        :module => BEL::Resource::Search::Plugins
+      )
+
+      module ClassMethods
+
+        # @param  [Hash<Symbol => Object>] options
+        # @return
+        def self.create_search(options = {})
+          fail NotImplementedError.new, "#{__method__} is not implemented"
+        end
+      end
+    end
+  end
+end

data/lib/bel/resource/search/api.rb

@@ -0,0 +1,36 @@
+module BEL::Resource::Search
+
+  module API
+
+    # Search identifiers based on +query_expression+.
+    #
+    # Additional parameters
+    #
+    # +concept_type+:
+    #   Searches on namespace values when set to +namespace_concept+.
+    #   Searches on annotation values when set to +annotation_concept+.
+    #   Otherwise, searches either namespace values or annotation values. This is the default.
+    #
+    # +scheme_uri+:
+    #   Searches within a specific namespace or annotation identified by this URI.
+    #   Otherwise, searches across all namespaces or annotations. This is the default.
+    #
+    # +species+:
+    #   Searches for namespace values or annotation values represented within the provided species. Values from
+    #   the NCBI Taxonomy are recognized (e.g. 9606, Homo sapiens, Human, etc.).
+    #   Otherwise, searches across all values regardless of species.
+    #
+    # +options+:
+    #   Options hash used to provide additional parameters to the search.
+    #
+    # @param query_expression [responds to #to_s] query expression
+    # @param concept_type     [responds to #to_s] concept type
+    # @param scheme_uri       [responds to #to_s] scheme uri
+    # @param species          [responds to #to_s] species
+    # @param options          [responds to #[]  ] options hash
+    # @return [Array<SearchResult>, nil]
+    def search(query_expression, concept_type = nil, scheme_uri = nil, species = nil, options = {})
+      fail NotImplementedError.new, "#{__method__} is not implemented"
+    end
+  end
+end

data/lib/bel/resource/search/search_result.rb

@@ -0,0 +1,32 @@
+module BEL
+  module Resource
+    module Search
+
+      # Represents an identifier search result.
+      #
+      # @example Create with all parameters
+      #   SearchResult.new(
+      #     'viral <b>oncogene</b> homolog',
+      #     'http://www.openbel.org/bel/namespace/hgnc-human-genes/391',
+      #     'http://www.openbel.org/bel/namespace/hgnc-human-genes',
+      #     '391',
+      #     'AKT1',
+      #     'v-akt murine thymoma viral oncogene homolog 1',
+      #     ['AKT', 'PKB', 'PRKBA', 'RAC']
+      #   )
+      #
+      # @example Create from hash
+      #   SearchResult.new({ :pref_label => 'AKT1' })
+      class SearchResult < Struct.new(:snippet, :uri, :scheme_uri, :identifier, :pref_label, :title, :alt_labels)
+        def initialize(*args)
+          if args.length == 1 && args.first.is_a?(Hash)
+            hash = args.first
+            super(*hash.values_at(*self.class.members))
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bel/translate.rb

@@ -0,0 +1,108 @@
+module BEL
+
+  # Translate module defines translation capabilities in the library. This
+  # module provides the API to use translator plugins.
+  #
+  # @see ::BEL::Translator::Plugins
+  module Translate
+
+    # Defines the translate API that is provided under the {BEL} module as a
+    # mixin.
+    module ClassMethods
+
+      # Return a stream of {::BEL::Model::Evidence} objects for the input.
+      #
+      # @param  [IO]                     input        the IO to read from
+      # @param  [Symbol]                 input_format the symbol that can be
+      #         used to identify the translator plugin that can read the
+      #         +input+
+      # @param  [Hash{Symbol => Object}] options
+      # @return [#each]                  an object that responds to +each+ and
+      #         provides {::BEL::Model::Evidence} objects
+      def evidence(input, input_format, options = {})
+        prepared_input = process_input(input)
+
+        in_translator  = self.translator(input_format) or
+          raise TranslateError.new(input_format)
+
+        in_translator.read(prepared_input)
+      end
+
+      # Translate from one file format to another using
+      # {::BEL::Model::Evidence} as a shared model. The translation is written
+      # to the IO +writer+ directly.
+      #
+      # @param  [IO]                     input         the IO to read from
+      # @param  [#to_sym]                input_format  the identifier for the
+      #         translator plugin that will read the +input+
+      # @param  [#to_sym]                output_format the identifier for the
+      #         translator plugin that will write to +writer+
+      # @param  [Hash{Symbol => Object}] options
+      # @return [IO   ]                  the IO +writer+ that the translation
+      #         was written to
+      def translate(input, input_format, output_format, writer = StringIO.new, options = {})
+        prepared_input = process_input(input)
+
+        in_translator  = self.translator(input_format) or
+          raise TranslateError.new(input_format)
+
+        out_translator = self.translator(output_format) or
+          raise TranslateError.new(output_format)
+
+        evidence = in_translator.read(prepared_input)
+        output   = out_translator.write(evidence, writer)
+        writer
+      end
+
+      # Return the {::BEL::Translator} plugin given an identifier.
+      #
+      # @param  [#to_sym]                input_format the identifier for the
+      #         translator plugin
+      # @param  [Hash{Symbol => Object}] options
+      # @return [::BEL::Translator]      the translator instance that is
+      #         responds to {::BEL::Translator#read} and
+      #         {::BEL::Translator#write}
+      def translator(input_format, options = {})
+        return nil unless input_format
+
+        id      = input_format.to_sym
+        plugins = BEL::Translator.plugins
+
+        plugin = plugins[id]
+        if plugin
+          plugin.create_translator(options)
+        else
+          match = BEL::Translator.plugins.values.find { |t|
+            match  = false
+            match |= (id == t.name.to_sym)
+            match |= (t.media_types.include?(id))
+            match |= (t.file_extensions.include?(id))
+            match
+          }
+          match.create_translator(options) if match
+        end
+      end
+
+      def process_input(input)
+        if input.respond_to? :read
+          input
+        elsif File.exist?(input)
+          File.open(input, :ext_enc => Encoding::UTF_8)
+        elsif input.respond_to? :to_s
+          input.to_s
+        end
+      end
+    end
+
+    # TranslateError represents an error when the specified format is not
+    # supported by any translator plugin.
+    class TranslateError < StandardError
+
+      FORMAT_ERROR = %Q{Format "%s" is not supported.}
+
+      def initialize(format)
+        super(FORMAT_ERROR % format)
+      end
+    end
+  end
+end