openbel-api 1.1.1-java → 1.2.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 121260d75016a848b38d53fd21034b6a3d487401
-  data.tar.gz: 23ebb2c2df88257a76db162dd0fbf05269977237
+  metadata.gz: afc3b945f3e3718c2be3732855cb00d83110c84a
+  data.tar.gz: 1d35a94f8f9799a6deaaa5b07ce3a30a44f4bb17
 SHA512:
-  metadata.gz: 07f857a7ae76c0635e722760896aa0b00bfa0d6d3b85cbfaf237bc7ef437d207cbab0b70002a74a620295d0c57de8664d9bf0e657dfff50449e9ea8c1c7053a8
-  data.tar.gz: 9db88ef3ef4d24699ed6ff66c060cfca5edf24ae4f591884512d9d5fc7a02223e88f0867aa4692934c4048c82166a6bda83adef66baa28d15fb5bc15954e4cf5
+  metadata.gz: 4646ef99f095e1235c249dca5f91e45e7db0c8979d24f3e5d0d0ab085b0cd2719c03fd24ad267aa1f8844c2d3e3c3eb2cd87da07180e0b36adf01ef09d81beef
+  data.tar.gz: ac9109a8b4594fd919bd73e40cdb75db784bf69ad32bb9526cc41205dc69a1acc4c0126a33bc434c8933bf916ca284d2f00db5d2e47a457dccd56ebd2fe7600e

data/CHANGELOG.md

@@ -3,6 +3,12 @@ All notable changes to openbel-api will be documented in this file. The curated
 
 This project adheres to [Semantic Versioning][Semantic Versioning].
 
+
+## [1.2.0][1.2.0] - 2017-01-22
+
+### Changed
+- strict=yes query param on POST /api/nanopub will result in a 422 if the BEL statement or Annotations are bad
+
 ## [1.1.0][1.1.0] - 2017-01-21
 
 ### Added

data/VERSION

@@ -1 +1 @@
-1.1.1
+1.2.0

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

@@ -94,6 +94,8 @@ module OpenBEL
               identifier       = annotation_value.identifier.first.to_s
               value_label      = annotation_value.pref_label.first.to_s
               if annotation_value
+                identifier  = annotation_value.identifier.first.to_s
+                value_label = annotation_value.pref_label.first.to_s
                 {
                   :name  => annotation_label,
                   :value => value_label,

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

@@ -1,4 +1,5 @@
 require 'bel'
+require 'bel_parser'
 require 'cgi'
 require 'openbel/api/nanopub/mongo'
 require 'openbel/api/nanopub/facet_filter'
@@ -14,10 +15,14 @@ module OpenBEL
       include OpenBEL::Nanopub::FacetFilter
       include OpenBEL::Resource::Nanopub
       include OpenBEL::Helpers
+      include BELParser::Parsers
 
       def initialize(app)
         super
 
+        bel_version = OpenBEL::Settings[:bel][:version]
+        @spec       = BELParser::Language.specification(bel_version)
+
         mongo = OpenBEL::Settings[:nanopub_store][:mongo]
         @api  = OpenBEL::Nanopub::Nanopub.new(mongo)
 
@@ -50,6 +55,20 @@ module OpenBEL
             }
           }
         }
+
+        @supported_namespaces = Hash[
+          @namespaces.each.map { |ns|
+            prefix = ns.prefix.first.upcase
+
+            [
+              prefix,
+              BELParser::Expression::Model::Namespace.new(
+                prefix,
+                ns.uri
+              )
+            ]
+          }
+        ]
       end
 
       configure :development do |config|
@@ -120,6 +139,165 @@ module OpenBEL
             new_hash
           end
         end
+
+        def validate_experiment_context(experiment_context)
+          valid_annotations   = []
+          invalid_annotations = []
+          experiment_context.values.each do |annotation|
+            name, value = annotation.values_at(:name, :value)
+            found_annotation  = @annotations.find(name).first
+
+            if found_annotation
+              if found_annotation.find(value).first == nil
+                # structured annotations, without a match, is invalid
+                invalid_annotations << annotation
+              else
+                # structured annotations, with a match, is invalid
+                valid_annotations << annotation
+              end
+            else
+              # free annotations considered valid
+              valid_annotations << annotation
+            end
+          end
+
+          [
+            invalid_annotations.empty? ? :valid : :invalid,
+            {
+              :valid               => invalid_annotations.empty?,
+              :valid_annotations   => valid_annotations,
+              :invalid_annotations => invalid_annotations,
+              :message             =>
+                invalid_annotations
+                  .map { |annotation|
+                    name, value = annotation.values_at(:name, :value)
+                    %Q{The value "#{value}" was not found in annotation "#{name}".}
+                  }
+                  .join("\n")
+            }
+          ]
+        end
+
+        def validate_statement(bel)
+          filter =
+            BELParser::ASTFilter.new(
+              BELParser::ASTGenerator.new("#{bel}\n"),
+              :simple_statement,
+              :observed_term,
+              :nested_statement
+            )
+          _, _, ast = filter.each.first
+
+          if ast.nil? || ast.empty?
+            return [
+              :syntax_invalid,
+              {
+                valid_syntax:    false,
+                valid_semantics: false,
+                message:         'Invalid syntax.',
+                warnings:        [],
+                term_signatures: []
+              }
+            ]
+          end
+
+          urir      = BELParser::Resource.default_uri_reader
+          urlr      = BELParser::Resource.default_url_reader
+          validator = BELParser::Language::ExpressionValidator.new(@spec, @supported_namespaces, urir, urlr)
+          message   = ''
+          terms     = ast.first.traverse.select { |node| node.type == :term }.to_a
+
+          semantics_functions =
+            BELParser::Language::Semantics.semantics_functions.reject { |fun|
+              fun == BELParser::Language::Semantics::SignatureMapping
+            }
+
+          result        = validator.validate(ast.first)
+          syntax_errors = result.syntax_results.map(&:to_s)
+
+          semantic_warnings =
+            ast
+              .first
+              .traverse
+              .flat_map { |node|
+                semantics_functions.flat_map { |func|
+                  func.map(node, @spec, @supported_namespaces)
+                }
+              }
+              .compact
+
+          if syntax_errors.empty? && semantic_warnings.empty?
+            valid = true
+          else
+            valid   = false
+            message = ''
+            message +=
+              syntax_errors.reduce('') { |msg, error|
+                msg << "#{error}\n"
+              }
+            message +=
+              semantic_warnings.reduce('') { |msg, warning|
+                msg << "#{warning}\n"
+              }
+            message << "\n"
+          end
+
+          term_semantics =
+            terms.map { |term|
+              term_result = validator.validate(term)
+              valid      &= term_result.valid_semantics?
+              bel_term    = serialize(term)
+
+              unless valid
+                message << "Term: #{bel_term}\n"
+                term_result.invalid_signature_mappings.map { |m|
+                  message << "  #{m}\n"
+                }
+                message << "\n"
+              end
+
+              {
+                term:               bel_term,
+                valid:              term_result.valid_semantics?,
+                errors:             term_result.syntax_results.map(&:to_s),
+                valid_signatures:   term_result.valid_signature_mappings.map(&:to_s),
+                invalid_signatures: term_result.invalid_signature_mappings.map(&:to_s)
+              }
+            }
+
+          [
+            valid ? :valid : :semantics_invalid,
+            {
+              expression:      bel,
+              valid_syntax:    true,
+              valid_semantics: valid,
+              message:         valid ? 'Valid semantics' : message,
+              errors:          syntax_errors,
+              warnings:        semantic_warnings.map(&:to_s),
+              term_signatures: term_semantics
+            }
+          ]
+        end
+
+        def validate_nanopub!(bel_statement, experiment_context)
+          stmt_result, stmt_validation     = validate_statement(bel_statement)
+          expctx_result, expctx_validation = validate_experiment_context(experiment_context)
+
+          return nil if stmt_result == :valid && expctx_result == :valid
+
+          halt(
+            422,
+            {'Content-Type' => 'application/json'},
+            render_json(
+              {
+                :nanopub_validation => {
+                  :bel_statement_validation      => stmt_validation,
+                  :experiment_context_validation => expctx_validation
+                }
+              }
+            )
+          )
+        end
       end
 
       options '/api/nanopubs' do
@@ -135,8 +313,10 @@ module OpenBEL
       post '/api/nanopubs' do
         # Validate BNJ.
         validate_media_type! "application/json"
+
+        strict = as_bool(params[:strict]) || false
+
         nanopub_obj = read_json
-        # STDERR.puts "DBG: nanopub_obj Variable config is #{nanopub_obj.inspect}"
         schema_validation = validate_schema(keys_to_s_deep(nanopub_obj), :nanopub)
         unless schema_validation[0]
           halt(
@@ -146,22 +326,46 @@ module OpenBEL
           )
         end
 
-        nanopub_hash                = nanopub_obj[:nanopub]
-        nanopub_hash[:references] ||= @default_references
+        nanopub_hash = nanopub_obj[:nanopub]
+        if nanopub_hash[:references]
+          nanopub_hash[:references] = {
+            :annotations => nanopub_hash[:references][:annotations].map { |anno|
+              {
+                :keyword => anno[:keyword],
+                :type    => :uri,
+                :domain  => anno[:uri]
+              }
+            },
+            :namespaces  => nanopub_hash[:references][:namespaces].map { |ns|
+              {
+                :keyword => ns[:keyword],
+                :type    => :uri,
+                :domain  => ns[:uri]
+              }
+            }
+          }
+        else
+          nanopub_hash[:references] = @default_references
+        end
+
+        original_bel_statement = nanopub_hash[:bel_statement]
 
-        nanopub = ::BEL::Nanopub::Nanopub.create(nanopub_hash)
-        # STDERR.puts "DBG: nanopub Variable config is #{nanopub.inspect}"
+        begin
+          nanopub = ::BEL::Nanopub::Nanopub.create(nanopub_hash)
+        rescue ArgumentError
+          nanopub_hash[:bel_statement] = nil
+          nanopub = ::BEL::Nanopub::Nanopub.create(nanopub_hash)
+        end
 
         # Standardize annotations.
         @annotation_transform.transform_nanopub!(nanopub, base_url)
 
-        # Build facets.
-        facets = map_nanopub_facets(nanopub)
-        hash = nanopub.to_h
-        hash[:bel_statement] = hash.fetch(:bel_statement, nil).to_s
-
-        # STDERR.puts "DBG: Variable config is #{hash.inspect}"
+        # Validate nanopub when strict is enabled.
+        validate_nanopub!(original_bel_statement, nanopub.experiment_context) if strict
 
+        facets               = map_nanopub_facets(nanopub)
+        hash                 = nanopub.to_h
+        hash[:bel_statement] = (hash[:bel_statement] || original_bel_statement).to_s
         hash[:facets]        = facets
         _id                  = @api.create_nanopub(hash)
 
@@ -235,6 +439,8 @@ module OpenBEL
 
         validate_media_type! "application/json"
 
+        strict = as_bool(params[:strict]) || false
+
         ev = @api.find_nanopub_by_id(object_id)
         halt 404 unless ev
 
@@ -248,14 +454,45 @@ module OpenBEL
           )
         end
 
-        nanopub_hash                = nanopub_obj[:nanopub]
-        nanopub_hash[:references] ||= @default_references
+        nanopub_hash = nanopub_obj[:nanopub]
+        if nanopub_hash[:references]
+          nanopub_hash[:references] = {
+            :annotations => nanopub_hash[:references][:annotations].map { |anno|
+              {
+                :keyword => anno[:keyword],
+                :type    => :uri,
+                :domain  => anno[:uri]
+              }
+            },
+            :namespaces  => nanopub_hash[:references][:namespaces].map { |ns|
+              {
+                :keyword => ns[:keyword],
+                :type    => :uri,
+                :domain  => ns[:uri]
+              }
+            }
+          }
+        else
+          nanopub_hash[:references] = @default_references
+        end
+
+        original_bel_statement = nanopub_hash[:bel_statement]
+
+        begin
+          nanopub = ::BEL::Nanopub::Nanopub.create(nanopub_hash)
+        rescue ArgumentError
+          nanopub_hash[:bel_statement] = nil
+          nanopub = ::BEL::Nanopub::Nanopub.create(nanopub_hash)
+        end
 
         # transformation
-        nanopub  = ::BEL::Nanopub::Nanopub.create(nanopub_hash)
         @annotation_transform.transform_nanopub!(nanopub, base_url)
 
+        # Validate nanopub when strict is enabled.
+        validate_nanopub!(original_bel_statement, nanopub.experiment_context) if strict
+
         facets                  = map_nanopub_facets(nanopub)
+        hash[:bel_statement]    = (hash[:bel_statement] || original_bel_statement).to_s
         nanopub                 = nanopub.to_h
         nanopub[:bel_statement] = nanopub.fetch(:bel_statement, nil).to_s
         nanopub[:facets]        = facets

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openbel-api
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: java
 authors:
 - Anthony Bargnesi