openbel-api 0.4.0-java

data/lib/openbel/api/cache/cache.rb

@@ -0,0 +1,30 @@
+module OpenBEL::Cache
+  module Cache
+
+    def [](key)
+      read(key)
+    end
+
+    def []=(key, value)
+      write(key, value)
+    end
+
+    def clear
+      purge
+    end
+
+    protected
+
+    def read(key)
+      fail NotImplementedError.new, "#{__method__} is not implemented"
+    end
+
+    def write(key, value)
+      fail NotImplementedError.new, "#{__method__} is not implemented"
+    end
+
+    def purge
+      fail NotImplementedError.new, "#{__method__} is not implemented"
+    end
+  end
+end

data/lib/openbel/api/config/config.rb

@@ -0,0 +1,33 @@
+require 'yaml'
+require_relative '../plugin/plugin_manager'
+
+module OpenBEL
+  module Config
+
+    CFG_VAR = 'OPENBEL_SERVER_CONFIG'
+    PLUGIN_PATHS = 'plugin_paths'
+
+    def self.load(config_file=nil)
+      config_file = ENV[CFG_VAR] || config_file
+      fail %Q{The configuration file is empty.} unless config_file
+
+      config = File.open(config_file, 'r:UTF-8') do |cf|
+        {}.merge(YAML::load(cf))
+      end
+
+      plugin_manager = PluginManager.new
+      plugin_manager.with_plugins_from([config.delete(PLUGIN_PATHS)].flatten.compact.map(&:to_s))
+      plugins = plugin_manager.to_a
+
+      errors = plugin_manager.check_configuration(plugins, config)
+
+      if !errors.empty?
+        fail RuntimeError.new(errors.join("\n"))
+      end
+
+      plugin_manager.configure_plugins(plugins.dup, config.dup)
+    end
+  end
+end
+# vim: ts=2 sts=2 sw=2 expandtab
+# encoding: utf-8

data/lib/openbel/api/evidence/api.rb

@@ -0,0 +1,39 @@
+module OpenBEL
+  module Evidence
+    module API
+
+      # single or array
+      def create_evidence(evidence)
+        fail NotImplementedError, "#{__method__} is not implemented"
+      end
+
+      def find_evidence_by_id(id)
+        fail NotImplementedError, "#{__method__} is not implemented"
+      end
+
+      def find_evidence(filters = [], offset = 0, length = 0, facet = false)
+        fail NotImplementedError, "#{__method__} is not implemented"
+      end
+
+      def count_evidence(filters = [])
+        fail NotImplementedError, "#{__method__} is not implemented"
+      end
+
+      def update_evidence_by_id(id, evidence_update)
+        fail NotImplementedError, "#{__method__} is not implemented"
+      end
+
+      def update_evidence_by_query(query, evidence_update)
+        fail NotImplementedError, "#{__method__} is not implemented"
+      end
+
+      def delete_evidence_by_id(id)
+        fail NotImplementedError, "#{__method__} is not implemented"
+      end
+
+      def delete_evidence_by_query(query)
+        fail NotImplementedError, "#{__method__} is not implemented"
+      end
+    end
+  end
+end

data/lib/openbel/api/evidence/facet_api.rb

@@ -0,0 +1,18 @@
+module OpenBEL
+  module Evidence
+    module FacetAPI
+
+      def create_facets(evidence)
+        fail NotImplementedError, "#{__method__} is not implemented"
+      end
+
+      def find_facets_by_filters(filters = [])
+        fail NotImplementedError, "#{__method__} is not implemented"
+      end
+
+      def remove_facets_by_filters(filters = [])
+        fail NotImplementedError, "#{__method__} is not implemented"
+      end
+    end
+  end
+end

data/lib/openbel/api/evidence/facet_filter.rb

@@ -0,0 +1,83 @@
+require 'multi_json'
+
+module OpenBEL
+  module Evidence
+    module FacetFilter
+
+      EMPTY = []
+      EVIDENCE_PARTS = [:citation, :experiment_context, :metadata]
+
+      def map_evidence_facets(evidence)
+        EVIDENCE_PARTS.reduce([]) { |facets, evidence_part|
+          part = evidence.send(evidence_part)
+          new_facets = self.send(:"map_#{evidence_part}_facets", part)
+          facets.concat(new_facets)
+        }
+      end
+
+      def map_citation_facets(citation)
+        if citation and citation.id
+          [
+            self.make_filter(:citation, :id, citation.id)
+          ]
+        else
+          EMPTY
+        end
+      end
+
+      def map_experiment_context_facets(experiment_context)
+        if experiment_context
+          experiment_context.flat_map { |annotation|
+            name  = annotation[:name]
+            value = annotation[:value]
+            if value.respond_to?(:each)
+              value.map { |v|
+                [:experiment_context, name, v]
+              }
+            else
+              # HACK: nested array will be flattened out by flat_map;
+              # otherwise we would have each data value unrolled
+              [[:experiment_context, name, value]]
+            end
+          }.select { |(_, _, value)|
+            value != nil
+          }.map { |filter|
+            self.make_filter(*filter)
+          }
+        else
+          EMPTY
+        end
+      end
+
+      def map_metadata_facets(metadata)
+        if metadata
+          metadata.flat_map { |name, value|
+            if value.respond_to?(:each)
+              value.map { |v|
+                [:metadata, name, v]
+              }
+            else
+              # HACK: nested array will be flattened out by flat_map;
+              # otherwise we would have each data value unrolled
+              [[:metadata, name, value]]
+            end
+          }.select { |_, _, value|
+            value != nil
+          }.map { |filter|
+            self.make_filter(*filter)
+          }
+        else
+          EMPTY
+        end
+      end
+
+      def make_filter(category, name, value)
+        MultiJson.dump({
+          :category => category,
+          :name     => name,
+          :value    => value,
+        })
+      end
+    end
+  end
+end

data/lib/openbel/api/evidence/mongo.rb

@@ -0,0 +1,247 @@
+require 'bel'
+require 'mongo'
+require_relative 'api'
+require_relative 'mongo_facet'
+
+module OpenBEL
+  module Evidence
+
+    class Evidence
+      include API
+      include Mongo
+
+      def initialize(options = {})
+        host             = options.delete(:host)
+        port             = options.delete(:port)
+        db               = options.delete(:database)
+        @db              = MongoClient.new(host, port).db(db)
+        @collection      = @db[:evidence]
+        @collection.ensure_index(
+          {:"bel_statement" => Mongo::ASCENDING },
+          :background => true
+        )
+        @collection.ensure_index(
+          {:"$**" => Mongo::TEXT },
+          :background => true
+        )
+        @evidence_facets = EvidenceFacets.new(
+          :host     => host,
+          :port     => port,
+          :database => db
+        )
+      end
+
+      def create_evidence(evidence)
+        # insert evidence; acknowledge journal
+        if evidence.respond_to?(:each_pair)
+          _id = @collection.insert(evidence, :w => 1, :j => true)
+
+          # remove evidence_facets after insert to facets
+          remove_evidence_facets(_id)
+          _id
+        elsif evidence.respond_to?(:each)
+          @collection.insert(evidence.to_a, :w => 1, :j => true)
+        else
+          raise "Evidence type #{evidence.class} cannot be inserted into Mongo."
+        end
+      end
+
+      def find_evidence_by_id(value)
+        @collection.find_one(to_id(value))
+      end
+
+      def find_evidence(filters = [], offset = 0, length = 0, facet = false)
+        query_hash = to_query(filters)
+        query_opts = query_options(
+          query_hash,
+          :skip  => offset,
+          :limit => length,
+          :sort  => [
+            [:bel_statement, :asc]
+          ]
+        )
+
+        results = {
+          :cursor => @collection.find(query_hash, query_opts)
+        }
+        if facet
+          facets_doc = @evidence_facets.find_facets(query_hash, filters)
+          results[:facets] = facets_doc["facets"]
+        end
+
+        results
+      end
+
+      def find_dataset_evidence(dataset, filters = [], offset = 0, length = 0, facet = false)
+        query_hash = to_query(filters)
+        query_hash[:$and] ||= []
+        query_hash[:$and].unshift({
+          :_dataset => dataset[:identifier]
+        })
+
+        query_opts = query_options(
+          query_hash,
+          :skip  => offset,
+          :limit => length,
+          :sort  => [
+            [:bel_statement, :asc]
+          ]
+        )
+
+        results = {
+          :cursor => @collection.find(query_hash, query_opts)
+        }
+        if facet
+          facets_doc = @evidence_facets.find_facets(query_hash, filters)
+          results[:facets] = facets_doc["facets"]
+        end
+
+        results
+      end
+
+      def count_evidence(filters = [])
+        query_hash = to_query(filters)
+        @collection.count(:query => query_hash)
+      end
+
+      def update_evidence_by_id(value, evidence)
+        # add ObjectId to update
+        _id = BSON::ObjectId(value)
+        evidence_h = evidence.to_h
+        evidence_h[:_id] = _id
+
+        # save evidence; acknowledge journal
+        @collection.save(evidence_h, :j => true)
+
+        # remove evidence_facets after update to facets
+        remove_evidence_facets(_id)
+        nil
+      end
+
+      def delete_dataset(identifier)
+        @collection.ensure_index(
+          {:"_dataset" => Mongo::ASCENDING },
+          :background => true
+        )
+
+        @collection.remove(
+          { :"_dataset" => identifier },
+          :j => true
+        )
+      end
+
+      def delete_evidence(value)
+        if value.respond_to?(:each)
+          value.each do |v|
+            delete_evidence_by_id(v)
+          end
+        else
+          delete_evidence_by_id(value)
+        end
+      end
+
+      def delete_evidence_by_query(query)
+        @collection.remove(
+          query,
+          :j => true
+        )
+      end
+
+      def delete_evidence_by_id(value)
+        # convert to ObjectId
+        begin
+          _id = to_id(value)
+        rescue BSON::InvalidObjectId
+          # indicate that a delete was unsuccessful
+          false
+        end
+
+        # remove evidence_facets before evidence removal
+        remove_evidence_facets(_id)
+
+        # remove evidence; returns true
+        @collection.remove(
+          {
+              :_id => _id
+          },
+          :j => true
+        )
+      end
+
+      private
+
+      def to_query(filters = [])
+        if !filters || filters.empty?
+          return {}
+        end
+
+        query_hash = {
+          :$and => filters.map { |filter|
+            category = filter['category']
+            name     = filter['name']
+            value    = filter['value']
+
+						if category == 'fts' && name == 'search'
+              {:$text => { :$search => value }}
+            elsif category == 'experiment_context'
+              {
+                :experiment_context => {
+                  :$elemMatch => {
+                    :name  => name.to_s,
+                    :value => value.to_s
+                  }
+                }
+              }
+            elsif category == 'metadata'
+              {
+                :metadata => {
+                  :$elemMatch => {
+                    :name  => name.to_s,
+                    :value => value.to_s
+                  }
+                }
+              }
+            else
+              {
+                "#{filter['category']}.#{filter['name']}" => filter['value'].to_s
+              }
+            end
+          }
+        }
+
+        query_hash
+      end
+
+      def query_options(query_hash, options = {})
+        if query_hash[:$text]
+          options[:fields] = [
+            {
+              :score => {
+                :$meta => "textScore"
+              }
+            }
+          ]
+          options[:sort].unshift(
+            [:score, {:$meta => "textScore"}]
+          )
+        end
+        options
+      end
+
+      def to_id(value)
+        BSON::ObjectId(value.to_s)
+      end
+
+      def remove_evidence_facets(_id)
+        evidence = @collection.find_one(_id, {
+          :fields => [ 'facets' ]
+        })
+
+        if evidence && evidence.has_key?('facets')
+          @evidence_facets.remove_facets_by_filters(evidence['facets'])
+          @evidence_facets.remove_facets_by_filters 
+        end
+      end
+    end
+  end
+end