openbel-api 0.4.0-java

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

@@ -0,0 +1,105 @@
+require 'mongo'
+require 'multi_json'
+require_relative 'facet_api'
+require_relative 'facet_filter'
+
+module OpenBEL
+  module Evidence
+
+    class EvidenceFacets
+      include FacetAPI
+      include Mongo
+      include FacetFilter
+
+      def initialize(options = {})
+        host             = options.delete(:host)
+        port             = options.delete(:port)
+        db               = options.delete(:database)
+        @db              = MongoClient.new(host, port).db(db)
+        @evidence        = @db[:evidence]
+        @evidence_facets = @db[:evidence_facets]
+      end
+
+      def create_facets(_id, query_hash)
+        # create and save facets, identified by query
+        facets_doc = _id.merge({
+          :facets => evidence_facets(query_hash)
+        })
+        @evidence_facets.save(facets_doc, :j => true)
+
+        # return facets document
+        facets_doc
+      end
+
+      def find_facets(query_hash, filters)
+        _id = {:_id => to_facets_id(filters)}
+        @evidence_facets.find_one(_id) || create_facets(_id, query_hash)
+      end
+
+      def remove_facets_by_filters(filters = [], options = {})
+        remove_spec =
+          if filters.empty?
+            { :_id => "" }
+          else
+            {
+              :_id => {
+                :$in => filters.map { |filter|
+                  to_regexp(MultiJson.load(filter))
+                }
+              }
+            }
+          end
+        @evidence_facets.remove(remove_spec, :j => true)
+      end
+
+      private
+
+      def to_regexp(filter)
+        filter_s = "#{filter['category']}|#{filter['name']}|#{filter['value']}"
+        %r{.*#{Regexp.escape(filter_s)}.*}
+      end
+
+
+      def to_facets_id(filters)
+        filters.map { |filter|
+          "#{filter['category']}|#{filter['name']}|#{filter['value']}"
+        }.sort.join(',')
+      end
+
+      def evidence_facets(query_hash = nil)
+        pipeline =
+          if query_hash.is_a?(Hash) && !query_hash.empty?
+            [{:'$match' => query_hash}] + AGGREGATION_PIPELINE
+          else
+            AGGREGATION_PIPELINE
+          end
+        @evidence.aggregate(pipeline)
+      end
+
+      AGGREGATION_PIPELINE = [
+        {
+          :'$project' => {
+            :_id => 0,
+            :facets => 1
+          }
+        },
+        {
+          :'$unwind' => '$facets'
+        },
+        {
+          :'$group' => {
+            :_id => '$facets',
+            :count => {
+              :'$sum' => 1
+            }
+          }
+        },
+        {
+          :'$sort' => {
+            :count => -1
+          }
+        }
+      ]
+    end
+  end
+end

data/lib/openbel/api/helpers/dependency_graph.rb

@@ -0,0 +1,52 @@
+require 'tsort'
+
+module OpenBEL
+  module Helpers
+
+    class DependencyGraph
+      include TSort
+
+      def initialize
+        @hash = Hash.new { |hash, key| hash[key] = [] }
+      end
+
+      def [](key)
+        @hash[key]
+      end
+
+      def add_dependency(first, *dependency_requirements)
+        @hash[first] ||= []
+        (dependency_requirements || []).flatten.each do |dep|
+          _add_dependency(first, dep)
+        end
+        @hash[first]
+      end
+
+      def delete(key)
+        @hash.delete(key)
+      end
+
+      def each_key(&block)
+        @hash.each_key(&block)
+      end
+
+      def tsort_each_child(key, &block)
+        @hash[key].each(&block)
+      end
+
+      def tsort_each_node(&block)
+        @hash.each_key(&block)
+      end
+
+      private
+
+      def _add_dependency(key1, key2)
+        @hash[key1] << key2
+        @hash[key2] = []
+        key2
+      end
+    end
+  end
+end
+# vim: ts=2 sts=2 sw=2 expandtab
+# encoding: utf-8

data/lib/openbel/api/model/rdf_resource.rb

@@ -0,0 +1,74 @@
+module OpenBEL
+  module Model
+
+    VOCABULARY_RDF = 'http://www.openbel.org/vocabulary/'
+
+    def self.included base
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def from(statements)
+        obj = self.new
+        statements.each do |sub, pred, obj_val|
+          index = pred.rindex('#') || pred.rindex('/')
+          if index
+            attribute = pred[index+1..-1]
+
+            # handle type statement
+            if attribute == 'type'
+              # ... the URI
+              if obj.respond_to?(:uri=)
+                obj.send(:uri=, sub)
+              end
+              # ... the BEL vocabulary type
+              if obj_val.start_with?(VOCABULARY_RDF) and obj.respond_to?(:type=)
+                obj.send(:type=, obj_val)
+                next
+              end
+            end
+            if obj.respond_to? :"#{attribute}="
+              obj.send(:"#{attribute}=", obj_val)
+            end
+          else
+            $stderr.puts "cannot parse local name for #{pred}"
+          end
+        end
+        (obj.respond_to? :uri and obj.uri) ? obj : nil
+      end
+    end
+
+    class RdfResource
+      include OpenBEL::Model
+
+      def initialize(attr_values = {})
+        attr_values.each { |k, v|
+          instance_variable_set(:"@#{k}", v)
+        }
+      end
+
+      attr_accessor :uri
+
+      def ==(other)
+        return false if other == nil
+        @uri == other.uri
+      end
+
+      def hash
+        @uri.hash
+      end
+
+      def to_hash
+        instance_variables.inject({}) { |res, attr|
+          res.merge({attr[1..-1] => instance_variable_get(attr)})
+        }
+      end
+
+      def to_s
+        @uri
+      end
+    end
+  end
+end
+# vim: ts=2 sts=2 sw=2
+# encoding: utf-8

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

@@ -0,0 +1,85 @@
+require 'pp'
+require_relative '../plugin'
+
+module OpenBEL
+  module Plugin
+
+    class CacheKyotoCabinet
+      include OpenBEL::Plugin
+
+      ID = 'kyotocabinet'
+      NAME = 'KyotoCabinet Cache'
+      DESC = 'Cache implementation using KyotoCabinet over FFI.'
+      MEMR_TYPES = [ :"memory-hash" ]
+      FILE_TYPES = [ :"file-hash" ]
+      TYPE_OPTION_VALUES = [ MEMR_TYPES, FILE_TYPES ].flatten
+      MODE_OPTION_VALUES = [ :reader, :writer, :create ]
+
+      CREATE_MUTEX = Mutex.new
+
+      def id
+        ID
+      end
+
+      def name
+        NAME
+      end
+
+      def description
+        DESC
+      end
+
+      def type
+        :cache
+      end
+
+      def on_load
+        require 'kyotocabinet_ffi'
+      end
+
+      def validate(extensions = {}, options = {})
+        type = options.delete(:type)
+        if not type
+          return ValidationError.new(self, :type, "Option is missing. Options are one of [#{TYPE_OPTION_VALUES.join(', ')}].")
+        end
+        type = type.to_sym
+        if not TYPE_OPTION_VALUES.include?(type)
+          return ValidationError.new(self, :type, "Value not supported. Options are one of [#{TYPE_OPTION_VALUES.join(', ')}].")
+        end
+
+        mode = options.delete(:mode)
+        if not mode
+          return ValidationError.new(self, :mode, "Option is missing. Options are one of [#{MODE_OPTION_VALUES.join(', ')}].")
+        end
+        mode = mode.map { |v| v.to_s.to_sym }
+
+        validation_successful
+      end
+
+      def configure(extensions = {}, options = {})
+        @options = options
+      end
+
+      def create_instance
+        CREATE_MUTEX.lock
+        begin
+          unless @instance
+            type = @options[:type].to_sym
+            mode = @options[:mode].map { |v| v.to_s.to_sym }
+
+            @instance = case type
+                        when :"memory-hash"
+                          KyotoCabinet::Db::MemoryHash.new mode
+                        when :"file-hash"
+                          KyotoCabinet::Db::PolymorphicDb::tmp_filedb(KyotoCabinet::FILE_HASH)
+                        end
+          end
+        ensure
+          CREATE_MUTEX.unlock
+        end
+
+        @instance
+      end
+    end
+  end
+end

data/lib/openbel/api/plugin/configure_plugins.rb

@@ -0,0 +1,97 @@
+require_relative '../helpers/dependency_graph'
+
+module OpenBEL
+  module ConfigurePlugins
+
+    def check_configuration(plugins, config)
+      sorted_plugin_config_ids = build_dependency_graph(config)
+
+      all_errors = []
+      valid_plugins = {}
+      sorted_plugin_config_ids.each do |plugin_config_id|
+        # validate plugin configuration...
+        plugin_config = config[plugin_config_id.to_s]
+
+        # ...check plugin defines required properties
+        ['type', 'plugin'].each do |p|
+          errors << %Q{The "#{p}" property (defined in "#{plugin_config_id}") does not define a type.} unless plugin_config.has_key?(p)
+          next
+        end
+        type = plugin_config['type']
+        plugin_id = plugin_config['plugin']
+
+        # ...check if any plugin(s) are loaded for specified type
+        if plugins.none? { |p| p.type.to_s.to_sym == type.to_s.to_sym }
+          errors << %Q{The "#{type}" type (defined in "#{plugin_config_id}") does not have any registered plugins.}
+        end
+
+        # ...check if plugin exists
+        plugin = plugins.find { |p| p.id == plugin_id }
+        unless plugin
+          errors << %Q{The "#{plugin_id}" plugin (defined in "#{plugin_config_id}") does not have any registered plugins.}
+        end
+
+        # ...check plugin extensions
+        extensions = plugin_config['extensions'] || {}
+        extensions.values.find_all { |ext|
+          not valid_plugins.has_key? ext.to_s
+        }.each do |ext|
+          all_errors << %Q{The "#{ext}" extension (defined in "#{plugin_config_id}") is not valid.}
+        end
+
+        # ...prepare extensions/options for plugin validation
+        extensions = Hash[extensions.map { |ext_type, ext_id|
+          [ext_type.to_s.to_sym, valid_plugins[ext_id.to_s]]
+        }]
+        options = Hash[(plugin_config['options'] || {}).map { |k, v|
+          [k.to_s.to_sym, v]
+        }]
+
+        # ...call plugin-specific validation
+        plugin_errors = [plugin.validate(extensions.dup, options.dup)].flatten.map(&:to_s)
+        if plugin_errors.empty?
+          valid_plugins[plugin_config_id.to_s] = plugin
+        else
+          all_errors.concat(plugin_errors)
+        end
+        # TODO Log successful plugin check if verbose.
+      end
+      all_errors
+    end
+
+    def configure_plugins(plugins, config)
+      sorted_plugin_config_ids = build_dependency_graph(config)
+      sorted_plugin_config_ids.inject({}) { |plugins_by_id, plugin_config_id|
+        plugin_config = config[plugin_config_id.to_s]
+
+        plugin_id = plugin_config['plugin']
+
+        plugin = plugins.find { |p| p.id == plugin_id }
+        extensions = Hash[(plugin_config['extensions'] || {}).map { |type, id|
+          [type.to_s.to_sym, plugins_by_id[id.to_s]]
+        }]
+        options = Hash[(plugin_config['options'] || {}).map { |k, v|
+          [k.to_s.to_sym, v]
+        }]
+
+        plugin.configure(extensions.dup, options.dup)
+        plugin.on_load
+
+        plugins_by_id[plugin_config_id.to_s] = plugin
+        plugins_by_id
+      }
+    end
+
+    private
+
+    def build_dependency_graph(config)
+      dependency_graph = Helpers::DependencyGraph.new
+      config.keys.each do |plugin_key|
+        block = config[plugin_key]
+        dependencies = (block['extensions'] || {}).each_value.to_a.map { |v| v.to_s.to_sym }
+        dependency_graph.add_dependency(plugin_key.to_s, *dependencies)
+      end
+      dependency_graph.tsort
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require_relative '../plugin'
+
+module OpenBEL
+  module Plugin
+
+    class Evidence
+      include OpenBEL::Plugin
+
+      ID = 'evidence'
+      NAME = 'OpenBEL Evidence API'
+      DESC = 'API for accesing OpenBEL Evidence.'
+
+      def id
+        ID
+      end
+
+      def name
+        NAME
+      end
+
+      def description
+        DESC
+      end
+
+      def type
+        :evidence
+      end
+
+      def required_extensions
+        []
+      end
+
+      def optional_extensions
+        []
+      end
+
+      def on_load
+        require_relative '../../evidence/mongo'
+      end
+
+      def validate(extensions = {}, options = {})
+        [:host, :port, :database].map { |setting|
+          unless options[setting]
+            ValidationError.new(self, :storage, "The #{setting} setting is missing.")
+          end
+        }.compact!
+      end
+
+      def configure(extensions = {}, options = {})
+        @options = options
+      end
+
+      def create_instance
+        OpenBEL::Evidence::Evidence.new(@options)
+      end
+    end
+  end
+end