openbel-api 0.4.0-java

data/app/openbel/api/resources/base.rb

@@ -0,0 +1,16 @@
+require 'oat'
+require 'oat/adapters/hal'
+require_relative 'adapters/basic_json'
+
+class BaseSerializer < Oat::Serializer
+
+  protected
+
+  def url
+    context[:url]
+  end
+
+  def base_url
+    context[:base_url]
+  end
+end

data/app/openbel/api/resources/completion.rb

@@ -0,0 +1,89 @@
+require_relative 'base'
+
+module OpenBEL
+  module Resource
+    module Expressions
+
+      class CompletionSerializer < BaseSerializer
+        adapter Oat::Adapters::HAL
+        schema do
+          type :completion
+          property :type,      item[:type]
+          property :label,     item[:label]
+          property :value,     item[:value]
+          property :highlight, item[:highlight]
+          property :actions,   item[:actions]
+          property :id,        item[:id]
+        end
+      end
+
+      class CompletionResourceSerializer < BaseSerializer
+        adapter Oat::Adapters::HAL
+        schema do
+          type :completion
+          properties do |p|
+            p.completion item
+          end
+
+          link :self,        link_self(item[:id])
+          link :describedby, link_described_by(item[:type], item[:id])
+        end
+
+        private
+
+        def link_self(id)
+          {
+            :type => 'completion',
+            :href => "#{base_url}/api/expressions/#{id}/completions"
+          }
+        end
+
+        def link_described_by(type, id)
+          case type
+          when :function
+            {
+              :type => 'function',
+              :href => "#{base_url}/api/functions/#{id}"
+            }
+          when :namespace_prefix
+            {
+              :type => 'namespace_prefix',
+              :href => "#{base_url}/api/namespaces/#{id}"
+            }
+          when :namespace_value
+            {
+              :type => 'namespace_value',
+              :href => "#{base_url}/api/namespaces/hgnc/#{id}"
+            }
+          else
+            raise NotImplementedError.new("Unexpected resource type, #{type}")
+          end
+        end
+      end
+
+      class CompletionCollectionSerializer < BaseSerializer
+        adapter Oat::Adapters::HAL
+
+        schema do
+          type :completion_collection
+          properties do |p|
+            p.completion_collection item
+          end
+
+          link :self,       link_self
+        end
+
+        private
+
+        def link_self
+          bel            = context[:bel]
+          caret_position = context[:caret_position]
+          {
+            :type => :completion_collection,
+            :href => "#{base_url}/api/expressions/#{bel}/completions?caret_position=#{caret_position}"
+          }
+        end
+      end
+    end
+  end
+end

data/app/openbel/api/resources/evidence.rb

@@ -0,0 +1,115 @@
+require 'bel'
+require_relative 'base'
+
+module OpenBEL
+  module Resource
+    module Evidence
+
+      class EvidenceSerializer < BaseSerializer
+        adapter Oat::Adapters::HAL
+
+        schema do
+          type :evidence
+          property :bel_statement,      item['bel_statement']
+          property :citation,           item['citation']
+          property :summary_text,       item['summary_text']
+          property :experiment_context, item['experiment_context']
+          property :metadata,           item['metadata']
+          property :id,                 item['_id']
+        end
+      end
+
+      class EvidenceResourceSerializer < BaseSerializer
+        adapter Oat::Adapters::HAL
+
+        schema do
+          type :evidence
+          properties do |p|
+            p.evidence item
+          end
+
+          link :self,         link_self
+          link :collection,   link_collection
+        end
+
+        private
+
+        def link_self
+          id = item[:id] || context[:_id]
+          item.delete(:id)
+          {
+            :type => :evidence,
+            :href => "#{base_url}/api/evidence/#{id}"
+          }
+        end
+
+        def link_collection
+          {
+            :type => :evidence_collection,
+            :href => "#{base_url}/api/evidence"
+          }
+        end
+      end
+
+      class EvidenceCollectionSerializer < BaseSerializer
+        adapter Oat::Adapters::HAL
+
+        schema do
+          type     :evidence_collection
+          property :evidence_collection,   item
+          property :facets,                context[:facets]
+          property :metadata,              context[:metadata]
+          link     :self,                  link_self
+          link     :start,                 link_start
+          link     :previous,              link_previous
+          link     :next,                  link_next
+        end
+
+        private
+
+        def link_self
+          start  = context[:start]
+          size   = context[:size]
+          {
+            :type => :evidence_collection,
+            :href => "#{base_url}/api/evidence?start=#{start}&size=#{size}&#{filter_query_params.join('&')}"
+          }
+        end
+
+        def link_start
+          size = context[:size]
+          {
+            :type => :evidence_collection,
+            :href => "#{base_url}/api/evidence?start=0&size=#{size}&#{filter_query_params.join('&')}"
+          }
+        end
+
+        def link_previous
+          previous_page = context[:previous_page]
+          return {} unless previous_page
+
+          {
+            :type => :evidence_collection,
+            :href => "#{base_url}/api/evidence?start=#{previous_page.start_offset}&size=#{previous_page.page_size}&#{filter_query_params.join('&')}"
+          }
+        end
+
+        def link_next
+          next_page = context[:next_page]
+          return {} unless next_page
+
+          {
+            :type => :evidence_collection,
+            :href => "#{base_url}/api/evidence?start=#{next_page.start_offset}&size=#{next_page.page_size}&#{filter_query_params.join('&')}"
+          }
+        end
+
+        def filter_query_params
+          context[:filters].map { |filter|
+            "filter=#{filter}"
+          }
+        end
+      end
+    end
+  end
+end

data/app/openbel/api/resources/evidence_transform.rb

@@ -0,0 +1,143 @@
+require 'bel'
+
+module OpenBEL
+  module Resource
+    module Evidence
+
+      class AnnotationTransform
+
+        SERVER_PATTERN = %r{/api/annotations/([^/]*)/values/([^/]*)/?}
+        RDFURI_PATTERN = %r{/bel/namespace/([^/]*)/([^/]*)/?}
+        URI_PATTERNS = [
+          %r{/api/annotations/([^/]*)/values/([^/]*)/?},
+          %r{/bel/namespace/([^/]*)/([^/]*)/?}
+        ]
+        ANNOTATION_VALUE_URI = "%s/api/annotations/%s/values/%s"
+
+        def initialize(annotations)
+          @annotations = annotations
+        end
+
+        def transform_evidence!(evidence, base_url)
+          if evidence
+            experiment_context = evidence.experiment_context
+            if experiment_context != nil
+              experiment_context.values.map! { |annotation|
+                transform_annotation(annotation, base_url)
+              }
+            end
+          end
+        end
+
+        def transform_annotation(annotation, base_url)
+          if annotation[:uri]
+            transformed = transform_uri(annotation[:uri], base_url)
+            return transformed if transformed != nil
+          end
+
+          if annotation[:name] && annotation[:value]
+            name  = annotation[:name]
+            value = annotation[:value]
+            transform_name_value(name, value, base_url)
+          elsif annotation.respond_to?(:each)
+            name  = annotation[0]
+            value = annotation[1]
+            transform_name_value(name, value, base_url)
+          end
+        end
+
+        private
+
+        def transform_uri(uri, base_url)
+          URI_PATTERNS.map { |pattern|
+            match = pattern.match(uri)
+            match ? transform_name_value(match[1], match[2], base_url) : nil
+          }.compact.first
+        end
+
+        def transform_name_value(name, value, base_url)
+          structured_annotation(name, value, base_url) || free_annotation(name, value)
+        end
+
+        def structured_annotation(name, value, base_url)
+          annotation = @annotations.find(name).first
+          if annotation
+            if value.respond_to?(:each)
+              {
+                :name  => annotation.prefLabel.to_s,
+                :value => value.map { |v|
+                  mapped = annotation.find(v).first
+                  mapped ? mapped.prefLabel.to_s : v
+                }
+              }
+            else
+              annotation_value = annotation.find(value).first
+              if annotation_value
+                {
+                  :name  => annotation.prefLabel.to_s,
+                  :value => annotation_value.prefLabel.to_s,
+                  :uri   => ANNOTATION_VALUE_URI % [
+                    base_url,
+                    annotation.prefix.to_s,
+                    annotation_value.identifier.to_s
+                  ]
+                }
+              else
+                {
+                  :name  => annotation.prefLabel.to_s,
+                  :value => value
+                }
+              end
+            end
+          end
+        end
+
+        def free_annotation(name, value)
+          {
+            :name  => normalize_annotation_name(name),
+            :value => value
+          }
+        end
+
+        def normalize_annotation_name(name, options = {})
+          name_s = name.to_s
+
+          if name_s.empty?
+            nil
+          else
+            name_s.
+              split(%r{[^a-zA-Z0-9]+}).
+              map! { |word| word.capitalize }.
+              join
+          end
+        end
+      end
+
+      class AnnotationGroupingTransform
+
+        ExperimentContext = ::BEL::Model::ExperimentContext
+
+        def transform_evidence!(evidence)
+          experiment_context = evidence.experiment_context
+          if experiment_context != nil
+            evidence.experiment_context = ExperimentContext.new(
+              experiment_context.group_by { |annotation|
+                annotation[:name]
+              }.values.map do |grouped_annotation|
+                {
+                  :name  => grouped_annotation.first[:name],
+                  :value => grouped_annotation.flat_map { |annotation|
+                    annotation[:value]
+                  },
+                  :uri   => grouped_annotation.flat_map { |annotation|
+                    annotation[:uri]
+                  }
+                }
+              end
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/app/openbel/api/resources/function.rb

@@ -0,0 +1,98 @@
+require 'bel'
+require_relative 'base'
+
+module OpenBEL
+  module Resource
+    module Functions
+
+      class FunctionSerializer < BaseSerializer
+        adapter Oat::Adapters::HAL
+
+        schema do
+          type :function
+          properties do |p|
+            p.short_form  item[:short_form]
+            p.long_form   item[:long_form]
+            p.description item[:description]
+            p.return_type item[:return_type]
+            p.signatures  item[:signatures]
+          end
+        end
+      end
+
+      class FunctionResourceSerializer < BaseSerializer
+        adapter Oat::Adapters::HAL
+
+        schema do
+          type :function
+          properties do |p|
+            p.functions      item
+          end
+
+          link :self,        link_self(item.first[:short_form])
+          link :next,        link_next
+          link :collection,  link_collection
+        end
+
+        private
+
+        def link_self(id)
+          {
+            :type => :function,
+            :href => "#{base_url}/api/functions/#{id}"
+          }
+        end
+
+        def link_collection
+          {
+            :type => :'function_collection',
+            :href => "#{base_url}/api/functions"
+          }
+        end
+
+        def link_next
+          fx_values = FUNCTIONS.values.uniq.sort_by { |fx|
+            fx[:short_form]
+          }
+          next_fx = fx_values[fx_values.index(item) + 1]
+          {
+            :type => :function,
+            :href => next_fx ?
+                       "#{base_url}/api/functions/#{next_fx[:short_form]}" :
+                       nil
+          }
+        end
+      end
+
+      class FunctionCollectionSerializer < BaseSerializer
+        adapter Oat::Adapters::HAL
+
+        schema do
+          type :'function_collection'
+          properties do |p|
+            p.functions      item
+          end
+
+          link :self,       link_self
+          link :start,      link_start(item.first[:short_form])
+        end
+
+        private
+
+        def link_self
+          {
+            :type => :'function_collection',
+            :href => "#{base_url}/api/functions"
+          }
+        end
+
+        def link_start(first_function)
+          {
+            :type => :function,
+            :href => "#{base_url}/api/functions/#{first_function}"
+          }
+        end
+      end
+    end
+  end
+end