openbel-api 0.6.2-java → 1.0.0-java

data/app/openbel/api/routes/language.rb

@@ -0,0 +1,118 @@
+require 'bel'
+require 'bel_parser'
+
+module OpenBEL
+  module Routes
+    # Language defines and implements the _/api/language_ routes to expose
+    # BEL functions, relationships, and version configured for the API.
+    class Language < Base
+
+      JSON             = Rack::Mime.mime_type('.json')
+      TEXT             = Rack::Mime.mime_type('.txt')
+      ACCEPTED_TYPES   = {'json' => JSON, 'text' => TEXT}
+      DEFAULT_TYPE     = TEXT
+
+      def initialize(app)
+        super
+        bel_version = OpenBEL::Settings[:bel][:version]
+        @spec       = BELParser::Language.specification(bel_version)
+      end
+
+      options '/api/language' do
+        response.headers['Allow'] = 'OPTIONS,GET'
+        status 200
+      end
+
+      options '/api/language/functions' do
+        response.headers['Allow'] = 'OPTIONS,GET'
+        status 200
+      end
+
+      options '/api/language/functions/:fx' do
+        response.headers['Allow'] = 'OPTIONS,GET'
+        status 200
+      end
+
+      options '/api/language/relationships' do
+        response.headers['Allow'] = 'OPTIONS,GET'
+        status 200
+      end
+
+      options '/api/language/relationships/:rel' do
+        response.headers['Allow'] = 'OPTIONS,GET'
+        status 200
+      end
+
+      options '/api/language/version' do
+        response.headers['Allow'] = 'OPTIONS,GET'
+        status 200
+      end
+
+      get '/api/language' do
+        response.headers['Content-Type'] = 'application/hal+json'
+        MultiJson.dump({
+          :_links => {
+            :item => [
+              {
+                :href => "#{base_url}/api/language/functions"
+              },
+              {
+                :href => "#{base_url}/api/language/relationships"
+              },
+              {
+                :href => "#{base_url}/api/language/version"
+              }
+            ]
+          }
+        })
+      end
+
+      get '/api/language/functions' do
+        render_collection(
+          @spec.functions.sort_by(&:long),
+          :function)
+      end
+
+      get '/api/language/functions/:fx' do
+        function = @spec.function(params[:fx].to_sym)
+        halt 404 unless function
+        render_resource(function, :function)
+      end
+
+      get '/api/language/relationships' do
+        render_collection(
+          @spec.relationships.sort_by(&:long),
+          :relationship)
+      end
+
+      get '/api/language/relationships/:rel' do
+        relationship = @spec.relationship(params[:rel].to_sym)
+        halt 404 unless relationship
+        render_resource(relationship, :relationship)
+      end
+
+      get '/api/language/version' do
+        accept_type = request.accept.find { |accept_entry|
+          ACCEPTED_TYPES.values.include?(accept_entry.to_s)
+        }
+        accept_type ||= DEFAULT_TYPE
+
+        format = params[:format]
+        if format
+          accept_type = ACCEPTED_TYPES[format]
+          halt 406 unless accept_type
+        end
+
+        render_json(
+          {
+            :bel_version => {
+              :string => OpenBEL::Settings[:bel][:version].to_s
+            }
+          }
+        )
+      end
+    end
+  end
+end
+# vim: ts=2 sw=2:
+# encoding: utf-8

data/app/openbel/api/routes/namespaces.rb

@@ -18,7 +18,7 @@ module OpenBEL
 
       RESULT_TYPES = {
         :resource => :all,
-        :name => :prefLabel,
+        :name => :pref_label,
         :identifier => :identifier,
         :title => :title
       }
@@ -92,7 +92,7 @@ module OpenBEL
 
         render_collection(
           namespaces.sort { |x,y|
-            x.prefLabel.to_s <=> y.prefLabel.to_s
+            x.pref_label.to_s <=> y.pref_label.to_s
           },
           :namespace
         )

data/app/openbel/api/routes/{evidence.rb → nanopubs.rb}

@@ -1,25 +1,25 @@
 require 'bel'
 require 'cgi'
-require 'openbel/api/evidence/mongo'
-require 'openbel/api/evidence/facet_filter'
-require_relative '../resources/evidence_transform'
-require_relative '../helpers/evidence'
+require 'openbel/api/nanopub/mongo'
+require 'openbel/api/nanopub/facet_filter'
+require_relative '../resources/nanopub_transform'
+require_relative '../helpers/nanopub'
 require_relative '../helpers/filters'
 require_relative '../helpers/pager'
 
 module OpenBEL
   module Routes
 
-    class Evidence < Base
-      include OpenBEL::Evidence::FacetFilter
-      include OpenBEL::Resource::Evidence
+    class Nanopubs < Base
+      include OpenBEL::Nanopub::FacetFilter
+      include OpenBEL::Resource::Nanopub
       include OpenBEL::Helpers
 
       def initialize(app)
         super
 
-        mongo = OpenBEL::Settings[:evidence_store][:mongo]
-        @api  = OpenBEL::Evidence::Evidence.new(mongo)
+        mongo = OpenBEL::Settings[:nanopub_store][:mongo]
+        @api  = OpenBEL::Nanopub::Nanopub.new(mongo)
 
         # RdfRepository using Jena
         @rr = BEL::RdfRepository.plugins[:jena].create_repository(
@@ -27,31 +27,30 @@ module OpenBEL
         )
 
         # Annotations using RdfRepository
-        annotations = BEL::Resource::Annotations.new(@rr)
-
-        @annotation_transform = AnnotationTransform.new(annotations)
+        annotations                    = BEL::Resource::Annotations.new(@rr)
+        @annotation_transform          = AnnotationTransform.new(annotations)
         @annotation_grouping_transform = AnnotationGroupingTransform.new
       end
 
       helpers do
 
-        def stream_evidence_objects(cursor)
+        def stream_nanopub_objects(cursor)
 
           stream :keep_open do |response|
-            cursor.each do |evidence|
-              evidence.delete('facets')
+            cursor.each do |nanopub|
+              nanopub.delete('facets')
 
               response << render_resource(
-                  evidence,
-                  :evidence,
+                  nanopub,
+                  :nanopub,
                   :as_array => false,
-                  :_id      => evidence['_id'].to_s
+                  :_id      => nanopub['_id'].to_s
               )
             end
           end
         end
 
-        def stream_evidence_array(cursor)
+        def stream_nanopub_array(cursor)
           stream :keep_open do |response|
             current = 0
 
@@ -63,14 +62,14 @@ module OpenBEL
             end
 
             response << '['
-            cursor.each do |evidence|
-              evidence.delete('facets')
+            cursor.each do |nanopub|
+              nanopub.delete('facets')
 
               response << render_resource(
-                  evidence,
-                  :evidence,
+                  nanopub,
+                  :nanopub,
                   :as_array => false,
-                  :_id      => evidence['_id'].to_s
+                  :_id      => nanopub['_id'].to_s
               )
               current += 1
               response << ',' if current < total
@@ -98,22 +97,22 @@ module OpenBEL
         end
       end
 
-      options '/api/evidence' do
+      options '/api/nanopubs' do
         response.headers['Allow'] = 'OPTIONS,POST,GET'
         status 200
       end
 
-      options '/api/evidence/:id' do
+      options '/api/nanopubs/:id' do
         response.headers['Allow'] = 'OPTIONS,GET,PUT,DELETE'
         status 200
       end
 
-      post '/api/evidence' do
-        # Validate JSON Evidence.
+      post '/api/nanopubs' do
+        # Validate BNJ.
         validate_media_type! "application/json"
-        evidence_obj = read_json
+        nanopub_obj = read_json
 
-        schema_validation = validate_schema(keys_to_s_deep(evidence_obj), :evidence)
+        schema_validation = validate_schema(keys_to_s_deep(nanopub_obj), :nanopub)
         unless schema_validation[0]
           halt(
             400,
@@ -122,39 +121,39 @@ module OpenBEL
           )
         end
 
-        evidence = ::BEL::Model::Evidence.create(evidence_obj[:evidence])
+        nanopub = ::BEL::Nanopub::Nanopub.create(nanopub_obj[:nanopub])
 
         # Standardize annotations.
-        @annotation_transform.transform_evidence!(evidence, base_url)
+        @annotation_transform.transform_nanopub!(nanopub, base_url)
 
         # Build facets.
-        facets = map_evidence_facets(evidence)
-        hash = evidence.to_h
+        facets = map_nanopub_facets(nanopub)
+        hash = nanopub.to_h
         hash[:bel_statement] = hash.fetch(:bel_statement, nil).to_s
         hash[:facets]        = facets
-        _id = @api.create_evidence(hash)
+        _id                  = @api.create_nanopub(hash)
 
         # Return Location information (201).
         status 201
-        headers "Location" => "#{base_url}/api/evidence/#{_id}"
+        headers "Location" => "#{base_url}/api/nanopubs/#{_id}"
       end
 
-			get '/api/evidence-stream', provides: 'application/json' do
+			get '/api/nanopubs-stream', provides: 'application/json' do
         start                = (params[:start] || 0).to_i
         size                 = (params[:size]  || 0).to_i
         group_as_array       = as_bool(params[:group_as_array])
 
         filters = validate_filters!
 
-        cursor  = @api.find_evidence(filters, start, size, false)[:cursor]
+        cursor  = @api.find_nanopub(filters, start, size, false)[:cursor]
         if group_as_array
-          stream_evidence_array(cursor)
+          stream_nanopub_array(cursor)
         else
-          stream_evidence_objects(cursor)
+          stream_nanopub_objects(cursor)
         end
 			end
 
-      get '/api/evidence' do
+      get '/api/nanopubs' do
         start                = (params[:start]  || 0).to_i
         size                 = (params[:size]   || 0).to_i
         faceted              = as_bool(params[:faceted])
@@ -162,46 +161,46 @@ module OpenBEL
 
         filters = validate_filters!
 
-        collection_total  = @api.count_evidence()
-        filtered_total    = @api.count_evidence(filters)
-        page_results      = @api.find_evidence(filters, start, size, faceted, max_values_per_facet)
+        collection_total  = @api.count_nanopub()
+        filtered_total    = @api.count_nanopub(filters)
+        page_results      = @api.find_nanopub(filters, start, size, faceted, max_values_per_facet)
 
-        render_evidence_collection(
-          'evidence-export', page_results, start, size, filters,
+        render_nanopub_collection(
+          'nanopub-export', page_results, start, size, filters,
           filtered_total, collection_total, @api
         )
       end
 
-      get '/api/evidence/:id' do
+      get '/api/nanopubs/:id' do
         object_id = params[:id]
         halt 404 unless BSON::ObjectId.legal?(object_id)
 
-        evidence = @api.find_evidence_by_id(object_id)
-        halt 404 unless evidence
+        nanopub = @api.find_nanopub_by_id(object_id)
+        halt 404 unless nanopub
 
-        evidence.delete('facets')
+        nanopub.delete('facets')
 
         # XXX Hack to return single resource wrapped as json array
-        # XXX Need to better support evidence resource arrays in base.rb
+        # XXX Need to better support nanopub resource arrays in base.rb
         render_resource(
-          evidence,
-          :evidence,
+          nanopub,
+          :nanopub,
           :as_array => false,
           :_id      => object_id
         )
       end
 
-      put '/api/evidence/:id' do
+      put '/api/nanopubs/:id' do
         object_id = params[:id]
         halt 404 unless BSON::ObjectId.legal?(object_id)
 
         validate_media_type! "application/json"
 
-        ev = @api.find_evidence_by_id(object_id)
+        ev = @api.find_nanopub_by_id(object_id)
         halt 404 unless ev
 
-        evidence_obj = read_json
-        schema_validation = validate_schema(keys_to_s_deep(evidence_obj), :evidence)
+        nanopub_obj = read_json
+        schema_validation = validate_schema(keys_to_s_deep(nanopub_obj), :nanopub)
         unless schema_validation[0]
           halt(
             400,
@@ -211,30 +210,30 @@ module OpenBEL
         end
 
         # transformation
-        evidence          = evidence_obj[:evidence]
-        evidence_model    = ::BEL::Model::Evidence.create(evidence)
-        @annotation_transform.transform_evidence!(evidence_model, base_url)
-        facets = map_evidence_facets(evidence_model)
-        evidence = evidence_model.to_h
-        evidence[:bel_statement] = evidence.fetch(:bel_statement, nil).to_s
-        evidence[:facets]        = facets
+        nanopub = nanopub_obj[:nanopub]
+        nanopub  = ::BEL::Nanopub::Nanopub.create(nanopub)
+        @annotation_transform.transform_nanopub!(nanopub, base_url)
+
+        facets                  = map_nanopub_facets(nanopub)
+        nanopub                 = nanopub.to_h
+        nanopub[:bel_statement] = nanopub.fetch(:bel_statement, nil).to_s
+        nanopub[:facets]        = facets
 
-        @api.update_evidence_by_id(object_id, evidence)
+        @api.update_nanopub_by_id(object_id, nanopub)
 
         status 202
       end
 
-      delete '/api/evidence/:id' do
+      delete '/api/nanopubs/:id' do
         object_id = params[:id]
         halt 404 unless BSON::ObjectId.legal?(object_id)
 
-        ev = @api.find_evidence_by_id(object_id)
+        ev = @api.find_nanopub_by_id(object_id)
         halt 404 unless ev
 
-        @api.delete_evidence_by_id(object_id)
+        @api.delete_nanopub_by_id(object_id)
         status 202
       end
-
     end
   end
 end

data/app/openbel/api/routes/root.rb

@@ -17,13 +17,13 @@ module OpenBEL
                 :href => "#{base_url}/api/annotations"
               },
               {
-                :href => "#{base_url}/api/evidence"
+                :href => "#{base_url}/api/nanopub"
               },
               {
                 :href => "#{base_url}/api/expressions"
               },
               {
-                :href => "#{base_url}/api/functions"
+                :href => "#{base_url}/api/language"
               },
               {
                 :href => "#{base_url}/api/namespaces"

data/app/openbel/api/routes/version.rb

@@ -1,45 +1,59 @@
-require_relative '../version'
-require 'rack/mime'
+require 'openbel/api/version'
 
 module OpenBEL
   module Routes
-
+    # Version defines and implements the _/api/version_ route that exposes
+    # the semantic version of the OpenBEL API.
     class Version < Base
 
       JSON             = Rack::Mime.mime_type('.json')
+      HAL              = 'application/hal+json'
       TEXT             = Rack::Mime.mime_type('.txt')
-      ACCEPTED_TYPES   = {'json' => JSON, 'text' => TEXT}
+      ACCEPTED_TYPES   = {
+        'hal'  => HAL,
+        'json' => JSON,
+        'text' => TEXT
+      }
       DEFAULT_TYPE     = TEXT
 
+      helpers do
+        def requested_media_type
+          if params && params[:format]
+            ACCEPTED_TYPES[params[:format]]
+          else
+            request.accept.flat_map { |accept_entry|
+              ACCEPTED_TYPES.values.find { |type| type == accept_entry.entry }
+            }.compact.first
+          end
+        end
+      end
+
       options '/api/version' do
         response.headers['Allow'] = 'OPTIONS,GET'
         status 200
       end
 
       get '/api/version' do
-        accept_type = request.accept.find { |accept_entry|
-          ACCEPTED_TYPES.values.include?(accept_entry.to_s)
-        }
-        accept_type ||= DEFAULT_TYPE
-
-        format = params[:format]
-        if format
-          accept_type = ACCEPTED_TYPES[format]
-          halt 406 unless accept_type
-        end
+        accept_type = requested_media_type || DEFAULT_TYPE
 
-        if accept_type == JSON
-          render_json(
-            {
-              :version => {
-                :string                    => OpenBEL::Version.to_s,
-                :semantic_version_numbers  => OpenBEL::Version.to_a
+        case accept_type
+        when TEXT
+          response.headers['Content-Type'] = 'text/plain'
+          OpenBEL::Version.to_s
+        when HAL, JSON
+          response.headers['Content-Type'] = 'application/hal+json'
+          MultiJson.dump({
+            :version => {
+              :string => OpenBEL::Version.to_s,
+              :semantic_version => {
+                :major => OpenBEL::Version::MAJOR,
+                :minor => OpenBEL::Version::MINOR,
+                :patch => OpenBEL::Version::PATCH
               }
             }
-          )
+          })
         else
-          response.headers['Content-Type'] = 'text/plain'
-          OpenBEL::Version.to_s
+          halt 406
         end
       end
     end