openbel-api 1.2.6-java → 1.2.7-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f3fe38f765f979c938f5706d7ffe2aa591ca8812
-  data.tar.gz: 515df8adf6f229acdfdcedee8a8416a2c50f5bea
+  metadata.gz: 60772f35d5cba63231bf2b925c748c58606af095
+  data.tar.gz: 8bc2ff556addbbf5abb156e39ced7a3ce1b8fd86
 SHA512:
-  metadata.gz: 17d2689e9d2e3b22c67f6551531c0c67371fff2a12fbd2ae3d6dc6f3dd58b5fe424c88a3da955f1d529ff46e411073f502a1c0c0b4724e2beb88433f4c8d9cca
-  data.tar.gz: 405557fc46a425265506dfb0e8af092ef6187e0349bd444bdce1a2877299bbfe19693aac80a3187e3e507808b5514c23226b5d26573ecba849ebdc3447443440
+  metadata.gz: 0c35fb15fb67b14b9a2b8fe3fc97187624c47bf281ab30d91f53b2104e7074366bd627fde75bdcd71a396da1a16c7a26c3ea43c84c026a0e4b677983dd398095
+  data.tar.gz: d2db63a059a447c718cb91c538645971122fda499cc981a668706948c6a8a5cf33b0974206b760442cd6e2c583280495f3dd02d8fac64d38fadf2eac63d0ad0c

data/README.md

@@ -273,6 +273,8 @@ Releases of *openbel-api* should follow these steps:
 
 Built with collaboration and a lot of :heart: by the [OpenBEL][OpenBEL] community.
 
+<a href="https://koding.com/"> <img src="https://koding-cdn.s3.amazonaws.com/badges/made-with-koding/v1/koding_badge_ReadmeLight.png" srcset="https://koding-cdn.s3.amazonaws.com/badges/made-with-koding/v1/koding_badge_ReadmeLight.png 1x, https://koding-cdn.s3.amazonaws.com/badges/made-with-koding/v1/koding_badge_ReadmeLight@2x.png 2x" alt="Made with Koding" /> </a>
+
 [OpenBEL]: http://www.openbel.org
 [OpenBEL Platform]: https://github.com/OpenBEL/openbel-platform
 [RAML]: http://raml.org/

data/VERSION

@@ -1 +1 @@
-1.2.6
+1.2.7

data/app/openbel/api/helpers/nanopub.rb

@@ -69,5 +69,164 @@ module OpenBEL
         end
       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
 end

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

@@ -44,8 +44,9 @@ module OpenBEL
             }
           when :namespace_value
             {
-              :type => 'namespace_value',
-              :href => "#{base_url}/api/namespaces/hgnc/#{id}"
+                # TODO Add namespace
+              # :type => 'namespace_value',
+              # :href => "#{base_url}/api/namespaces/#{namespace}/values/#{id}"
             }
           when :relationship
             {

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

@@ -71,7 +71,7 @@ module OpenBEL
         end
 
         def base_url
-          STDERR.puts "DBG: Variable config is #{env.inspect}"
+          # STDERR.puts "DBG: Variable config is #{env.inspect}"
           if env['SERVER_NAME'] == 'localhost'
             scheme = 'http'
           else

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

@@ -136,28 +136,28 @@ module OpenBEL
               )
             end
 
-            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, DC.identifier, identifier_statement.object)
-              )
-            }
-
-            if existing_dataset
-              dataset_uri = existing_dataset.subject.to_s
-              headers 'Location' => dataset_uri
-              halt(
-                  409,
-                  { 'Content-Type' => 'application/json' },
-                  render_json(
-                      {
-                          :status => 409,
-                          :msg => %Q{The dataset document matches an existing dataset resource by identifier "#{identifier_statement.object}".},
-                          :location => dataset_uri
-                      }
-                  )
-              )
-            end
+            # 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, DC.identifier, identifier_statement.object)
+            #   )
+            # }
+
+            # if existing_dataset
+            #   dataset_uri = existing_dataset.subject.to_s
+            #   headers 'Location' => dataset_uri
+            #   halt(
+            #       409,
+            #       { 'Content-Type' => 'application/json' },
+            #       render_json(
+            #           {
+            #               :status => 409,
+            #               :msg => %Q{The dataset document matches an existing dataset resource by identifier "#{identifier_statement.object}".},
+            #               :location => dataset_uri
+            #           }
+            #       )
+            #   )
+            # end
 
             [void_dataset_uri, void_dataset]
           ensure
@@ -216,6 +216,7 @@ module OpenBEL
 
           dataset
         end
+
       end
 
       options '/api/datasets' do
@@ -270,6 +271,8 @@ the "multipart/form-data" content type. Allowed dataset content types are: #{ACC
         # Check dataset in request for suitability and conflict with existing resources.
         void_dataset_uri, void_dataset = check_dataset(io, type)
 
+        # STDERR.puts "DBG: Variable config is #{void_dataset_uri.inspect}"
+
         # Create dataset in RDF.
         @rr.insert_statements(void_dataset)
 
@@ -298,6 +301,13 @@ the "multipart/form-data" content type. Allowed dataset content types are: #{ACC
           hash[:_dataset]            = dataset_id
           hash[:bel_statement]       = hash[:bel_statement].to_s
 
+          # Validate nanopub
+          original_bel_statement = hash[:bel_statement].to_s
+
+          # STDERR.puts "DBG: Variable config is #{original_bel_statement.inspect}"
+          # STDERR.puts "DBG: Variable config is #{nanopub.experiment_context.inspect}"
+          # validate_nanopub!(original_bel_statement, nanopub.experiment_context)
+
           nanopub_batch << hash
 
           if nanopub_batch.size == MONGO_BATCH
@@ -335,6 +345,7 @@ the "multipart/form-data" content type. Allowed dataset content types are: #{ACC
 
         status 201
         headers 'Location' => void_dataset_uri.to_s
+        render_json({"Location": void_dataset_uri.to_s})
       end
 
       get '/api/datasets/:id' do

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

@@ -140,164 +140,6 @@ module OpenBEL
           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
@@ -361,6 +203,8 @@ module OpenBEL
         @annotation_transform.transform_nanopub!(nanopub, base_url)
 
         # Validate nanopub when strict is enabled.
+        # STDERR.puts "DBG: Variable config is #{original_bel_statement.inspect}"
+        # STDERR.puts "DBG: Variable config is #{nanopub.experiment_context.inspect}"
         validate_nanopub!(original_bel_statement, nanopub.experiment_context) if strict
 
         facets               = map_nanopub_facets(nanopub)