openbel-api 0.6.2-java → 1.0.0-java

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

@@ -58,7 +58,7 @@ module OpenBEL
 
         render_collection(
           annotations.sort { |x,y|
-            x.prefLabel.to_s <=> y.prefLabel.to_s
+            x.pref_label.to_s <=> y.pref_label.to_s
           },
           :annotation
         )

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

@@ -3,8 +3,9 @@ require 'json_schema'
 require 'multi_json'
 require_relative '../resources/annotation'
 require_relative '../resources/completion'
-require_relative '../resources/evidence'
+require_relative '../resources/nanopub'
 require_relative '../resources/function'
+require_relative '../resources/relationship'
 require_relative '../resources/match_result'
 require_relative '../resources/namespace'
 require_relative '../schemas'
@@ -14,9 +15,10 @@ module OpenBEL
 
     class Base < Sinatra::Application
       include OpenBEL::Resource::Annotations
-      include OpenBEL::Resource::Evidence
+      include OpenBEL::Resource::Nanopub
       include OpenBEL::Resource::Expressions
       include OpenBEL::Resource::Functions
+      include OpenBEL::Resource::Relationships
       include OpenBEL::Resource::MatchResults
       include OpenBEL::Resource::Namespaces
       include OpenBEL::Schemas
@@ -36,15 +38,17 @@ module OpenBEL
         :completion_collection      => CompletionCollectionSerializer,
         :function                   => FunctionResourceSerializer,
         :function_collection        => FunctionCollectionSerializer,
+        :relationship               => RelationshipResourceSerializer,
+        :relationship_collection    => RelationshipCollectionSerializer,
         :match_result               => MatchResultResourceSerializer,
         :match_result_collection    => MatchResultCollectionSerializer,
         :namespace                  => NamespaceResourceSerializer,
         :namespace_collection       => NamespaceCollectionSerializer,
         :namespace_value            => NamespaceValueResourceSerializer,
         :namespace_value_collection => NamespaceValueCollectionSerializer,
-        :evidence                   => EvidenceSerializer,
-        :evidence_resource          => EvidenceResourceSerializer,
-        :evidence_collection        => EvidenceCollectionSerializer
+        :nanopub                    => NanopubSerializer,
+        :nanopub_resource           => NanopubResourceSerializer,
+        :nanopub_collection         => NanopubCollectionSerializer
       }
 
       disable :protection
@@ -111,9 +115,9 @@ module OpenBEL
           end
         end
 
-        def read_evidence
+        def read_nanopub
           halt 415 unless ::BEL.translator(request.media_type)
-          ::BEL.evidence(request.body, request.media_type, :symbolize_keys => true)
+          ::BEL.nanopub(request.body, request.media_type, :symbolize_keys => true)
         end
 
         def read_json

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

@@ -1,12 +1,14 @@
 require 'bel'
 require 'bel/util'
 require 'rdf'
+require 'rdf/vocab'
 require 'cgi'
 require 'multi_json'
-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 'openbel/api/helpers/uuid_generator'
+require_relative '../resources/nanopub_transform'
+require_relative '../helpers/nanopub'
 require_relative '../helpers/filters'
 require_relative '../helpers/pager'
 
@@ -14,9 +16,10 @@ module OpenBEL
   module Routes
 
     class Datasets < Base
-      include OpenBEL::Evidence::FacetFilter
-      include OpenBEL::Resource::Evidence
+      include OpenBEL::Nanopub::FacetFilter
+      include OpenBEL::Resource::Nanopub
       include OpenBEL::Helpers
+      include OpenBEL::Helpers::UUIDGenerator
 
       DEFAULT_TYPE = 'application/hal+json'
       ACCEPTED_TYPES = {
@@ -28,15 +31,20 @@ module OpenBEL
 
       MONGO_BATCH     = 500
       FACET_THRESHOLD = 10000
+      DC              = ::RDF::Vocab::DC
+      VOID            = ::RDF::Vocab::VOID
+      FOAF            = ::RDF::Vocab::FOAF
 
       def initialize(app)
         super
 
         BEL.translator(:rdf)
 
-        # Evidence API using Mongo.
-        mongo = OpenBEL::Settings[:evidence_store][:mongo]
-        @api  = OpenBEL::Evidence::Evidence.new(mongo)
+        @bel_version = OpenBEL::Settings[:bel][:version]
+
+        # nanopub API using Mongo.
+        mongo = OpenBEL::Settings[:nanopub_store][:mongo]
+        @api  = OpenBEL::Nanopub::Nanopub.new(mongo)
 
         # RdfRepository using Jena.
         @rr = BEL::RdfRepository.plugins[:jena].create_repository(
@@ -63,19 +71,19 @@ module OpenBEL
 
         def check_dataset(io, type)
           begin
-            evidence         = BEL.evidence(io, type).each.first
+            nanopub         = BEL.nanopub(io, type).each.first
 
-            unless evidence
+            unless nanopub
               halt(
                 400,
                 { 'Content-Type' => 'application/json' },
-                render_json({ :status => 400, :msg => 'No BEL evidence was provided. Evidence is required to infer dataset information.' })
+                render_json({ :status => 400, :msg => 'No BEL nanopub was provided. nanopub is required to infer dataset information.' })
               )
             end
 
-            void_dataset_uri = RDF::URI("#{base_url}/api/datasets/#{self.generate_uuid}")
+            void_dataset_uri = RDF::URI("#{base_url}/api/datasets/#{generate_uuid}")
 
-            void_dataset = evidence.to_void_dataset(void_dataset_uri)
+            void_dataset = nanopub.to_void_dataset(void_dataset_uri)
             unless void_dataset
               halt(
                   400,
@@ -85,7 +93,7 @@ module OpenBEL
             end
 
             identifier_statement = void_dataset.query(
-                RDF::Statement.new(void_dataset_uri, RDF::DC.identifier, nil)
+                RDF::Statement.new(void_dataset_uri, DC.identifier, nil)
             ).to_a.first
             unless identifier_statement
               halt(
@@ -100,10 +108,10 @@ module OpenBEL
               )
             end
 
-            datasets         = @rr.query_pattern(RDF::Statement.new(nil, RDF.type, RDF::VOID.Dataset))
+            datasets         = @rr.query_pattern(RDF::Statement.new(nil, RDF.type, VOID.Dataset))
             existing_dataset = datasets.find { |dataset_statement|
               @rr.has_statement?(
-                  RDF::Statement.new(dataset_statement.subject, RDF::DC.identifier, identifier_statement.object)
+                  RDF::Statement.new(dataset_statement.subject, DC.identifier, identifier_statement.object)
               )
             }
 
@@ -131,24 +139,24 @@ module OpenBEL
 
         def dataset_exists?(uri)
           @rr.has_statement?(
-            RDF::Statement.new(uri, RDF.type, RDF::VOID.Dataset)
+            RDF::Statement.new(uri, RDF.type, VOID.Dataset)
           )
         end
 
         def retrieve_dataset(uri)
           dataset = {}
           identifier = @rr.query(
-            RDF::Statement.new(uri, RDF::DC.identifier, nil)
+            RDF::Statement.new(uri, DC.identifier, nil)
           ).first
           dataset[:identifier] = identifier.object.to_s if identifier
 
           title = @rr.query(
-            RDF::Statement.new(uri, RDF::DC.title, nil)
+            RDF::Statement.new(uri, DC.title, nil)
           ).first
           dataset[:title] = title.object.to_s if title
 
           description = @rr.query(
-            RDF::Statement.new(uri, RDF::DC.description, nil)
+            RDF::Statement.new(uri, DC.description, nil)
           ).first
           dataset[:description] = description.object.to_s if description
 
@@ -158,22 +166,22 @@ module OpenBEL
           dataset[:waiver] = waiver.object.to_s if waiver
 
           creator = @rr.query(
-            RDF::Statement.new(uri, RDF::DC.creator, nil)
+            RDF::Statement.new(uri, DC.creator, nil)
           ).first
           dataset[:creator] = creator.object.to_s if creator
 
           license = @rr.query(
-            RDF::Statement.new(uri, RDF::DC.license, nil)
+            RDF::Statement.new(uri, DC.license, nil)
           ).first
           dataset[:license] = license.object.to_s if license
 
           publisher = @rr.query(
-            RDF::Statement.new(uri, RDF::DC.publisher, nil)
+            RDF::Statement.new(uri, DC.publisher, nil)
           ).first
           if publisher
             publisher.object
             contact_info = @rr.query(
-              RDF::Statement.new(publisher.object, RDF::FOAF.mbox, nil)
+              RDF::Statement.new(publisher.object, FOAF.mbox, nil)
             ).first
             dataset[:contact_info] = contact_info.object.to_s if contact_info
           end
@@ -240,58 +248,58 @@ the "multipart/form-data" content type. Allowed dataset content types are: #{ACC
         dataset    = retrieve_dataset(void_dataset_uri)
         dataset_id = dataset[:identifier]
 
-        # Add batches of read evidence objects; save to Mongo and RDF.
+        # Add batches of read nanopub objects; save to Mongo and RDF.
         # TODO Add JRuby note regarding Enumerator threading.
-        evidence_count = 0
-        evidence_batch = []
+        nanopub_count = 0
+        nanopub_batch = []
 
         # Clear out all facets before loading dataset.
         @api.delete_facets
 
-        BEL.evidence(io, type).each do |ev|
+        BEL.nanopub(io, type, :language => @bel_version).each do |nanopub|
           # Standardize annotations from experiment_context.
-          @annotation_transform.transform_evidence!(ev, base_url)
-
-          ev.metadata[:dataset] = dataset_id
-          facets                = map_evidence_facets(ev)
-          ev.bel_statement      = ev.bel_statement.to_s
-          hash                  = BEL.object_convert(String, ev.to_h) { |str|
-                                    str.gsub(/\n/, "\\n").gsub(/\r/, "\\r")
-                                  }
-          hash[:facets]         = facets
+          @annotation_transform.transform_nanopub!(nanopub, base_url)
+
+          nanopub.metadata[:dataset] = dataset_id
+          facets                     = map_nanopub_facets(nanopub)
+          hash                       = BEL.object_convert(String, nanopub.to_h) { |str|
+                                         str.gsub(/\n/, "\\n").gsub(/\r/, "\\r")
+                                       }
+          hash[:facets]              = facets
           # Create dataset field for efficient removal.
-          hash[:_dataset]       = dataset_id
+          hash[:_dataset]            = dataset_id
+          hash[:bel_statement]       = hash[:bel_statement].to_s
 
-          evidence_batch << hash
+          nanopub_batch << hash
 
-          if evidence_batch.size == MONGO_BATCH
-            _ids = @api.create_evidence(evidence_batch)
+          if nanopub_batch.size == MONGO_BATCH
+            _ids = @api.create_nanopub(nanopub_batch)
 
             dataset_parts = _ids.map { |object_id|
-              RDF::Statement.new(void_dataset_uri, RDF::DC.hasPart, object_id.to_s)
+              RDF::Statement.new(void_dataset_uri, DC.hasPart, object_id.to_s)
             }
             @rr.insert_statements(dataset_parts)
 
-            evidence_batch.clear
+            nanopub_batch.clear
 
             # Clear out all facets after FACET_THRESHOLD nanopubs have been seen.
-            evidence_count += MONGO_BATCH
-            if evidence_count >= FACET_THRESHOLD
+            nanopub_count += MONGO_BATCH
+            if nanopub_count >= FACET_THRESHOLD
               @api.delete_facets
-              evidence_count = 0
+              nanopub_count = 0
             end
           end
         end
 
-        unless evidence_batch.empty?
-          _ids = @api.create_evidence(evidence_batch)
+        unless nanopub_batch.empty?
+          _ids = @api.create_nanopub(nanopub_batch)
 
           dataset_parts = _ids.map { |object_id|
-            RDF::Statement.new(void_dataset_uri, RDF::DC.hasPart, object_id.to_s)
+            RDF::Statement.new(void_dataset_uri, DC.hasPart, object_id.to_s)
           }
           @rr.insert_statements(dataset_parts)
 
-          evidence_batch.clear
+          nanopub_batch.clear
         end
 
         # Clear out all facets after the dataset is completely loaded.
@@ -314,15 +322,15 @@ the "multipart/form-data" content type. Allowed dataset content types are: #{ACC
                 :type => 'dataset',
                 :href => void_dataset_uri.to_s
             },
-            :evidence_collection => {
-              :type => 'evidence_collection',
-              :href => "#{base_url}/api/datasets/#{id}/evidence"
+            :nanopub_collection => {
+              :type => 'nanopub_collection',
+              :href => "#{base_url}/api/datasets/#{id}/nanopub"
             }
           }
         })
       end
 
-      get '/api/datasets/:id/evidence' do
+      get '/api/datasets/:id/nanopub' do
         id = params[:id]
         void_dataset_uri = RDF::URI("#{base_url}/api/datasets/#{id}")
         halt 404 unless dataset_exists?(void_dataset_uri)
@@ -336,12 +344,12 @@ the "multipart/form-data" content type. Allowed dataset content types are: #{ACC
 
         filters = validate_filters!
 
-        collection_total  = @api.count_evidence
-        filtered_total    = @api.count_evidence(filters)
-        page_results      = @api.find_dataset_evidence(dataset, filters, start, size, faceted, max_values_per_facet)
+        collection_total  = @api.count_nanopub
+        filtered_total    = @api.count_nanopub(filters)
+        page_results      = @api.find_dataset_nanopub(dataset, filters, start, size, faceted, max_values_per_facet)
         name              = dataset[:identifier].gsub(/[^\w]/, '_')
 
-        render_evidence_collection(
+        render_nanopub_collection(
           name, page_results, start, size, filters,
           filtered_total, collection_total, @api
         )
@@ -349,7 +357,7 @@ the "multipart/form-data" content type. Allowed dataset content types are: #{ACC
 
       get '/api/datasets' do
         dataset_uris = @rr.query(
-          RDF::Statement.new(nil, RDF.type, RDF::VOID.Dataset)
+          RDF::Statement.new(nil, RDF.type, VOID.Dataset)
         ).map { |statement|
           statement.subject
         }.to_a
@@ -363,9 +371,9 @@ the "multipart/form-data" content type. Allowed dataset content types are: #{ACC
                     :type => 'dataset',
                     :href => uri.to_s
                 },
-                :evidence_collection => {
-                    :type => 'evidence_collection',
-                    :href => "#{uri}/evidence"
+                :nanopub_collection => {
+                    :type => 'nanopub_collection',
+                    :href => "#{uri}/nanopub"
                 }
             }
           }
@@ -381,7 +389,7 @@ the "multipart/form-data" content type. Allowed dataset content types are: #{ACC
         halt 404 unless dataset_exists?(void_dataset_uri)
 
         dataset = retrieve_dataset(void_dataset_uri)
-        # XXX Removes all facets due to load of many evidence.
+        # XXX Removes all facets due to load of many nanopub.
         @api.delete_dataset(dataset[:identifier])
         @rr.delete_statement(RDF::Statement.new(void_dataset_uri, nil, nil))
 
@@ -390,7 +398,7 @@ the "multipart/form-data" content type. Allowed dataset content types are: #{ACC
 
       delete '/api/datasets' do
         datasets = @rr.query(
-          RDF::Statement.new(nil, RDF.type, RDF::VOID.Dataset)
+          RDF::Statement.new(nil, RDF.type, VOID.Dataset)
         ).map { |stmt|
           stmt.subject
         }.to_a
@@ -398,31 +406,13 @@ the "multipart/form-data" content type. Allowed dataset content types are: #{ACC
 
         datasets.each do |void_dataset_uri|
           dataset = retrieve_dataset(void_dataset_uri)
-          # XXX Removes all facets due to load of many evidence.
+          # XXX Removes all facets due to load of many nanopub.
           @api.delete_dataset(dataset[:identifier])
           @rr.delete_statement(RDF::Statement.new(void_dataset_uri, nil, nil))
         end
 
         status 202
       end
-
-      private
-
-      unless self.methods.include?(:generate_uuid)
-
-        # Dynamically defines an efficient UUID method for the current ruby.
-        if RUBY_ENGINE =~ /^jruby/i
-          java_import 'java.util.UUID'
-          define_method(:generate_uuid) do
-            Java::JavaUtil::UUID.random_uuid.to_s
-          end
-        else
-          require 'uuid'
-          define_method(:generate_uuid) do
-            UUID.generate
-          end
-        end
-      end
     end
   end
 end

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

@@ -1,6 +1,11 @@
 require 'cgi'
 require 'bel'
 require 'uri'
+require 'bel_parser/expression/model'
+require 'bel_parser/expression/parser'
+require 'bel_parser/expression/validator'
+require 'bel_parser/resources'
+require 'bel_parser/resource/jena_tdb_reader'
 
 module OpenBEL
   module Routes
@@ -10,6 +15,10 @@ module OpenBEL
       def initialize(app)
         super
 
+        # Obtain configured BEL version.
+        bel_version   = OpenBEL::Settings[:bel][:version]
+        @spec         = BELParser::Language.specification(bel_version)
+
         # RdfRepository using Jena.
         @rr = BEL::RdfRepository.plugins[:jena].create_repository(
           :tdb_directory => OpenBEL::Settings[:resource_rdf][:jena][:tdb_directory]
@@ -25,7 +34,11 @@ module OpenBEL
           :database_file => OpenBEL::Settings[:resource_search][:sqlite][:database_file]
         )
 
-        @sequence_variation = SequenceVariationFunctionHasLocationPredicate.new
+        @expression_validator = BELParser::Expression::Validator.new(
+          @spec,
+          BELParser::Resources::DEFAULT_NAMESPACES,
+          BELParser::Resource.default_uri_reader,
+          BELParser::Resource.default_url_reader)
       end
 
       options '/api/expressions/*/completions' do
@@ -43,26 +56,11 @@ module OpenBEL
         status 200
       end
 
-      options '/api/expressions/*/syntax-validations/?' do
+      options '/api/expressions/*/validation-result/?' do
         response.headers['Allow'] = 'OPTIONS,GET'
         status 200
       end
 
-      options '/api/expressions/*/semantic-validations/?' do
-        response.headers['Allow'] = 'OPTIONS,GET'
-        status 200
-      end
-
-      # options '/api/expressions/*/ortholog' do
-      #   response.headers['Allow'] = 'OPTIONS,GET'
-      #   status 200
-      # end
-
-      # options '/api/expressions/*/ortholog/:species' do
-      #   response.headers['Allow'] = 'OPTIONS,GET'
-      #   status 200
-      # end
-
       helpers do
 
         def normalize_relationship(relationship)
@@ -73,22 +71,28 @@ module OpenBEL
         def statement_components(bel_statement, flatten = false)
           obj = {}
           if flatten
-            obj[:subject]      = bel_statement.subject ? bel_statement.subject.to_bel : nil
-            obj[:relationship] = normalize_relationship(bel_statement.relationship)
-            obj[:object]       = bel_statement.object ? bel_statement.object.to_bel : nil
+            obj.merge!({
+              :subject      => bel_statement.subject ? bel_statement.subject.to_s : nil,
+              :relationship => bel_statement.relationship && bel_statement.relationship.long,
+              :object       => bel_statement.object ? bel_statement.object.to_s : nil
+            })
           else
-            obj[:subject]      = term_components(bel_statement.subject)
-            obj[:relationship] = normalize_relationship(bel_statement.relationship)
-            obj[:object]       = term_components(bel_statement.object)
+            obj.merge!({
+              :subject      => term_components(bel_statement.subject),
+              :relationship => bel_statement.relationship && bel_statement.relationship.to_h,
+              :object       => term_components(bel_statement.object)
+            })
           end
+
           obj
         end
 
         def arg_components(bel_argument)
-          if bel_argument.respond_to? :fx
-            term_components(bel_argument)
-          elsif bel_argument.respond_to? :ns
+          case bel_argument
+          when BELParser::Expression::Model::Parameter
             parameter_components(bel_argument)
+          when BELParser::Expression::Model::Term
+            term_components(bel_argument)
           else
             nil
           end
@@ -99,7 +103,7 @@ module OpenBEL
 
           {
             :term => {
-              :fx        => bel_term.fx,
+              :function  => bel_term.function.to_h,
               :arguments => bel_term.arguments.map { |a| arg_components(a) }
             }
           }
@@ -107,14 +111,39 @@ module OpenBEL
 
         def parameter_components(bel_parameter)
           return nil unless bel_parameter
+          namespace = bel_parameter.namespace && bel_parameter.namespace.to_s
 
           {
             :parameter => {
-              :ns        => bel_parameter.ns ? bel_parameter.ns.prefix : nil,
+              :namespace => namespace,
               :value     => bel_parameter.value.to_s
             }
           }
         end
+
+        def syntax_results(results)
+          results.select do |res|
+            res.is_a? BELParser::Language::Syntax::SyntaxResult
+          end
+        end
+
+        def semantics_results(results)
+          results.select do |res|
+            res.is_a? BELParser::Language::Semantics::SemanticsResult
+          end
+        end
+
+        def successfully_matched_signatures(results)
+          results.select do |res|
+            res.is_a?(BELParser::Language::Semantics::SignatureMappingSuccess)
+          end
+        end
+
+        def signature_warnings(results)
+          results.select do |res|
+            res.is_a?(BELParser::Language::Semantics::SignatureMappingWarning)
+          end
+        end
       end
 
       get '/api/expressions/*/completions/?' do
@@ -123,7 +152,7 @@ module OpenBEL
         halt 400 unless bel and caret_position
 
         begin
-          completions = BEL::Completion.complete(bel, @search, @namespaces, caret_position)
+          completions = BEL::Completion.complete(bel, @spec, @search, @namespaces, caret_position)
         rescue IndexError => ex
           halt(
             400,
@@ -145,9 +174,10 @@ module OpenBEL
         bel     = params[:splat].first
         flatten = as_bool(params[:flatten])
 
-        statement = BEL::Script.parse(bel).find { |obj|
-          obj.is_a? BEL::Model::Statement
-        }
+        statement =
+          BELParser::Expression.parse_statements(
+            bel,
+            @spec)
         halt 404 unless statement
 
         response.headers['Content-Type'] = 'application/json'
@@ -163,23 +193,27 @@ module OpenBEL
         flatten     = as_bool(params[:flatten])
         inner_terms = as_bool(params[:inner_terms])
 
-        terms = BEL::Script.parse(bel).select { |obj|
-          obj.is_a? BEL::Model::Term
-        }
+        terms =
+          BELParser::Expression.parse_terms(
+            bel,
+            @spec)
+        halt 404 if terms.empty?
 
         if !functions.empty?
           functions = functions.map(&:to_sym)
-          terms = terms.select { |term|
-            functions.any? { |match|
-              term.fx.short_form == match || term.fx.long_form == match
-            }
-          }
+          terms =
+            terms.select do |term|
+              functions.any? { |match| term.function === match }
+            end
         end
 
         if inner_terms
-          terms = terms.flat_map { |term|
-            term.arguments.select { |arg| arg.is_a? BEL::Model::Term }
-          }
+          terms =
+            terms.flat_map do |term|
+              term.arguments.select do |arg|
+                arg.is_a?(BELParser::Expression::Model::Term)
+              end
+            end
         end
 
         terms = terms.to_a
@@ -188,7 +222,7 @@ module OpenBEL
         response.headers['Content-Type'] = 'application/json'
         if flatten
           MultiJson.dump({
-            :terms => terms.map { |term| term.to_bel }
+            :terms => terms.map { |term| term.to_s }
           })
         else
           MultiJson.dump({
@@ -197,360 +231,16 @@ module OpenBEL
         end
       end
 
-      # TODO Relies on LibBEL.bel_parse_statement which is not currently supported.
-      # get '/api/expressions/*/ortholog/:species' do
-      #   bel              = params[:splat].first
-      #   species          = params[:species]
-      #   taxon_annotation = @annotations.find('taxon').first
-      #
-      #   unless taxon_annotation
-      #     halt(
-      #       404,
-      #       { 'Content-Type' => 'application/json' },
-      #       render_json({
-      #         :status => 404,
-      #         :msg    => 'Could not find NCBI Taxonomy annotation.'
-      #       })
-      #     )
-      #   end
-      #
-      #   species = taxon_annotation.find(species).first
-      #
-      #   if species
-      #     species = species.identifier.to_s
-      #   else
-      #     halt(
-      #       400,
-      #       { 'Content-Type' => 'application/json' },
-      #       render_json({
-      #         :status => 400,
-      #         :msg    => %Q{Could not find species "#{params[:species]}"}
-      #       })
-      #     )
-      #   end
-      #
-      #   bel_ast = BEL::Parser.parse(bel)
-      #
-      #   if bel_ast.any?([@sequence_variation])
-      #     msg = 'Could not orthologize sequence variation terms with location'
-      #     halt(
-      #       404,
-      #       { 'Content-Type' => 'application/json' },
-      #       render_json({
-      #         :status => 404,
-      #         :msg    => msg
-      #       })
-      #     )
-      #   end
-      #
-      #   param_transform = ParameterOrthologTransform.new(
-      #       @namespaces, @annotations, species
-      #   )
-      #   transformed_ast = bel_ast.transform_tree([param_transform])
-      #
-      #   if !param_transform.parameter_errors.empty?
-      #     parameters = param_transform.parameter_errors.map { |p|
-      #       p.join(':')
-      #     }.join(', ')
-      #     halt(
-      #       404,
-      #       { 'Content-Type' => 'application/json' },
-      #       render_json({
-      #         :status => 404,
-      #         :msg    => "Could not orthologize #{parameters}"
-      #       })
-      #     )
-      #   end
-      #
-      #   # serialize AST to BEL
-      #   bel_serialization = BELSerializationTransform.new
-      #   transformed_ast.transform_tree([bel_serialization])
-      #
-      #   # write response
-      #   response.headers['Content-Type'] = 'application/json'
-      #   MultiJson.dump({
-      #     :original     => bel,
-      #     :species      => params[:species],
-      #     :orthologized => bel_serialization.bel_string
-      #   })
-      # end
-
-      # BEL Syntax Validation
-      # TODO Move out to a separate route.
-      get '/api/expressions/*/syntax-validations/?' do
-        halt 501
-      end
-
-      # BEL Semantic Validations
-      # TODO Move out to a separate route.
-      get '/api/expressions/*/semantic-validations/?' do
-        halt 501
-      end
-
-      class SequenceVariationFunctionHasLocationPredicate
-        include BEL::LibBEL
-
-        SEQUENCE_VARIATION_FX = [
-          'fus', 'fusion',
-          'pmod', 'proteinModification',
-          'sub', 'substitution',
-          'trunc', 'truncation'
-        ]
-
-        def call(ast_node)
-          # check if AST node is a TERM
-          if !ast_node.is_a?(BelAstNodeToken) || ast_node.token_type != :BEL_TOKEN_TERM
-            return false
-          end
-
-          # check if AST node is a pmod TERM
-          if !SEQUENCE_VARIATION_FX.include?(ast_node.left.to_typed_node.value)
-            return false
-          end
-
-          # walk arg AST nodes until terminal
-          arg_node = ast_node.right.to_typed_node
-          while !(arg_node.left.pointer.null? && arg_node.right.pointer.null?)
-            # check if NV token child
-            arg_token = arg_node.left.to_typed_node
-
-            if arg_token.token_type == :BEL_TOKEN_NV
-              # true if namespace value is an integer
-              node_value = arg_token.right.to_typed_node.value
-              if integer?(node_value)
-                return true
-              end
-            end
-
-            # advance to the next ARG
-            arg_node = arg_node.right.to_typed_node
-          end
-
-          return false
-        end
-
-        private
-
-        def integer?(value)
-          begin
-            Integer(value)
-            return true
-          rescue ArgumentError
-            return false
-          end
-        end
-      end
-
-      class ParameterOrthologTransform
-        include BEL::LibBEL
-
-        NAMESPACE_PREFERENCE = [
-          "hgnc",
-          "mgi",
-          "rgd",
-          "gocc",
-          "scomp",
-          "meshcs",
-          "sfam",
-          "gobp",
-          "meshpp",
-          "chebi",
-          "schem",
-          "do",
-          "meshd",
-          "sdis",
-          "sp",
-          "affx",
-          "egid",
-        ]
-
-        def initialize(namespaces, annotations, species_tax_id)
-          @namespaces = namespaces
-          @orthology = OrthologAdapter.new(
-            namespaces, species_tax_id
-          )
-          @species_tax_id = species_tax_id
-          @parameter_errors = []
-        end
-
-        def parameter_errors
-          @parameter_errors.uniq
-        end
-
-        def call(ast_node)
-          if ast_node.is_a?(BelAstNodeToken) &&
-              ast_node.token_type == :BEL_TOKEN_NV
-
-            ns_value = [
-              ast_node.left.to_typed_node.value,
-              ast_node.right.to_typed_node.value
-            ]
-            orthologs = @orthology[ns_value]
-            if !orthologs.empty?
-              orthologs.sort_by! { |ortholog| namespace_preference(ortholog) }
-              ortholog = orthologs.first
-              BEL::LibBEL::bel_free_ast_node(ast_node.left.pointer)
-              ast_node.left  = BelAstNode.new(
-                bel_new_ast_node_value(:BEL_VALUE_PFX, ortholog[0].upcase)
-              )
-
-              BEL::LibBEL::bel_free_ast_node(ast_node.right.pointer)
-              ast_node.right = BelAstNode.new(
-                bel_new_ast_node_value(:BEL_VALUE_VAL, ortholog[1])
-              )
-            else
-              # flag as ortholog error if this parameter has a namespace and
-              # the namespace value is either not known or its species differs
-              # from our target
-              if ns_value[0] != nil
-                namespace, value = ns_value
-                namespace        = @namespaces.find(namespace).first
-                if namespace
-                  value = namespace.find(value).first
-                  if !value || value.fromSpecies != @species_tax_id
-                    @parameter_errors << value
-                  end
-                end
-              end
-            end
-          end
-        end
-
-        private
-
-        def namespace_preference(ortholog)
-          NAMESPACE_PREFERENCE.index(ortholog[0])
-        end
-      end
-
-      class BELSerializationTransform
-        include BEL::LibBEL
-
-        attr_reader :bel_string
-
-        def initialize
-          @bel_string = ""
-        end
-
-        def call(ast_node)
-          if ast_node.is_a?(BelAstNodeToken)
-            case ast_node.token_type
-            when :BEL_TOKEN_STATEMENT
-            when :BEL_TOKEN_SUBJECT
-            when :BEL_TOKEN_OBJECT
-            when :BEL_TOKEN_REL
-            when :BEL_TOKEN_TERM
-            when :BEL_TOKEN_ARG
-            when :BEL_TOKEN_NV
-            end
-          else
-            case ast_node.value_type
-            when :BEL_VALUE_FX
-              function(ast_node.value)
-            when :BEL_VALUE_REL
-              relationship(ast_node.value)
-            when :BEL_VALUE_PFX
-              namespace_prefix(ast_node.value)
-            when :BEL_VALUE_VAL
-              namespace_value(ast_node.value)
-            end
-          end
-        end
-
-        def between(ast_node)
-          if ast_node.is_a?(BelAstNodeToken)
-            case ast_node.token_type
-            when :BEL_TOKEN_STATEMENT
-            when :BEL_TOKEN_SUBJECT
-            when :BEL_TOKEN_OBJECT
-            when :BEL_TOKEN_REL
-            when :BEL_TOKEN_TERM
-            when :BEL_TOKEN_ARG
-              token_arg(ast_node)
-            when :BEL_TOKEN_NV
-            end
-          end
-        end
-
-        def after(ast_node)
-          if ast_node.is_a?(BelAstNodeToken)
-            case ast_node.token_type
-            when :BEL_TOKEN_STATEMENT
-            when :BEL_TOKEN_SUBJECT
-            when :BEL_TOKEN_OBJECT
-            when :BEL_TOKEN_REL
-            when :BEL_TOKEN_TERM
-              @bel_string.concat(')')
-            when :BEL_TOKEN_ARG
-            when :BEL_TOKEN_NV
-            end
-          end
-        end
-
-        private
-
-        def token_arg(ast_node)
-          chained_arg_node = ast_node.right
-          if !chained_arg_node.pointer.null?
-            chained_arg_node = chained_arg_node.to_typed_node
-            if !chained_arg_node.left.pointer.null? ||
-               !chained_arg_node.right.pointer.null?
-              @bel_string.concat(', ')
-            end
-          end
-        end
-
-        def function(fx)
-          @bel_string.concat(fx).concat('(')
-        end
-
-        def relationship(rel)
-          @bel_string.concat(" #{rel} ")
-        end
-
-        def namespace_prefix(prefix)
-          return unless prefix
-          @bel_string.concat(prefix).concat(':')
-        end
-
-        def namespace_value(value)
-          @bel_string.concat(value)
-        end
-      end
-
-      # Hash-like
-      class OrthologAdapter
-
-        EMPTY = [].freeze
-
-        def initialize(namespaces, species_tax_id)
-          @namespaces = namespaces
-          @species_tax_id = species_tax_id
-        end
-
-        def [](key)
-          namespace, value = key
+      # Produce validation result for BEL expression using the current language.
+      get '/api/expressions/*/validation/?' do
+        bel = params[:splat].first
+        response.headers['Content-Type'] = 'text/plain'
 
-          if value.start_with?('"') && value.end_with?('"')
-            value = value[1...-1]
-          end
+        @expression_validator.each(
+          StringIO.new("#{bel}\n")
+        ) do |(num, line, ast, result)|
 
-          namespace = @namespaces.find(namespace).first
-          return EMPTY unless namespace
-          value     = namespace.find(value).first
-          return EMPTY unless value
-          orthologs = value.orthologs.select { |orth|
-            orth.fromSpecies == @species_tax_id
-          }.to_a
-          return EMPTY if orthologs.empty?
-
-          orthologs.map! { |ortholog_value|
-            [
-              ortholog_value.namespace.prefix,
-              ortholog_value.prefLabel
-            ]
-          }
-          orthologs
+          return result.to_s
         end
       end
     end