opentox-client 0.0.1pre → 0.0.2pre

data/lib/error.rb

@@ -45,20 +45,19 @@ module OpenTox
     OpenTox.const_set klass,c
     
     # define global methods for raising errors, eg. bad_request_error
-    Object.send(:define_method, klass.underscore.to_sym) do |message|
-      defined?(@uri) ? uri = @uri : uri=nil
-      # TODO: insert uri from sinatra
+    Object.send(:define_method, klass.underscore.to_sym) do |message,uri=nil|
       raise c, message, uri
     end
   end
   
   # Errors received from RestClientWrapper calls
   class RestCallError < Error
-    attr_accessor :request, :response
-    def initialize request, response, message
+    attr_accessor :request#, :response
+    def initialize message, request, uri
+    #def initialize request, response, message
       @request = request
-      @response = response
-      super 502, message, request.url
+      #@response = response
+      super 502, message, uri
     end
   end
 
@@ -66,16 +65,24 @@ module OpenTox
   class ErrorReport
     def initialize http_code, error
       @http_code = http_code
-      #@report = report#.to_yaml
       @report = {}
-      @report[RDF::OT.actor] = error.uri
-      @report[RDF::OT.message] = error.message
+      @report[RDF::OT.actor] = error.uri.to_s
+      @report[RDF::OT.message] = error.message.to_s
       @report[RDF::OT.statusCode] = @http_code 
       @report[RDF::OT.errorCode] = error.class.to_s
-      @report[RDF::OT.errorDetails] = caller.collect{|line| line unless line =~ /#{File.dirname(__FILE__)}/}.compact.join("\n")
+
+      # cut backtrace
+      backtrace = caller.collect{|line| line unless line =~ /#{File.dirname(__FILE__)}/}.compact
+      cut_index = backtrace.find_index{|line| line.match /sinatra|minitest/}
+      cut_index ||= backtrace.size
+      cut_index -= 1
+      cut_index = backtrace.size-1 if cut_index < 0
+      @report[RDF::OT.errorDetails] = backtrace[0..cut_index].join("\n")
       @report[RDF::OT.errorDetails] += "REST paramenters:\n#{error.request.args.inspect}" if defined? error.request
-      @report[RDF::OT.message] += "\n" + error.response.body if defined? error.response
+      #@report[RDF::OT.message] += "\n" + error.response.body.to_s if defined? error.response
       # TODO fix Error cause
+      # should point to another errorReport, but errorReports do not have URIs
+      # create a separate service?
       #report[RDF::OT.errorCause] = @report if defined?(@report) 
     end
 
@@ -84,6 +91,10 @@ module OpenTox
 
       send :define_method, "to_#{format}".to_sym do
         rdf = RDF::Writer.for(format).buffer do |writer|
+          # TODO: not used for turtle
+          # http://rdf.rubyforge.org/RDF/Writer.html#
+          writer.prefix :ot, RDF::URI('http://www.opentox.org/api/1.2#')
+          writer.prefix :ot1_1, RDF::URI('http://www.opentox.org/api/1.1#')
           subject = RDF::Node.new
           @report.each do |predicate,object|
             writer << [subject, predicate, object] if object

data/lib/opentox-client.rb

@@ -5,6 +5,7 @@ require 'rdf/raptor'
 require "rest-client"
 require 'uri'
 require 'yaml'
+require 'json'
 require 'logger'
 
 # define constants and global variables
@@ -14,7 +15,7 @@ RDF::OT1 =  RDF::Vocabulary.new 'http://www.opentox.org/api/1.1#'
 RDF::OTA =  RDF::Vocabulary.new 'http://www.opentox.org/algorithmTypes.owl#'
 
 #CLASSES = ["Compound", "Feature", "Dataset", "Algorithm", "Model", "Validation", "Task", "ErrorReport", "Investigation"]
-CLASSES = ["Compound", "Feature", "Dataset", "Algorithm", "Model", "Validation", "Task", "Investigation"]
+CLASSES = ["Generic", "Compound", "Feature", "Dataset", "Algorithm", "Model", "Validation", "Task", "Investigation"]
 RDF_FORMATS = [:rdfxml,:ntriples,:turtle]
 $default_rdf = "application/rdf+xml"
 
@@ -25,8 +26,10 @@ FALSE_REGEXP = /^(false|inactive|0|0.0|low tox|deactivating|non-carcinogen|non-m
 require File.join(File.dirname(__FILE__),"overwrite.rb")
 require File.join(File.dirname(__FILE__),"error.rb")
 require File.join(File.dirname(__FILE__),"rest-client-wrapper.rb") 
+require File.join(File.dirname(__FILE__),"authorization.rb") 
+require File.join(File.dirname(__FILE__),"policy.rb") 
 require File.join(File.dirname(__FILE__),"otlogger.rb") # avoid require conflicts with logger
 require File.join(File.dirname(__FILE__),"opentox.rb")
 require File.join(File.dirname(__FILE__),"task.rb")
 require File.join(File.dirname(__FILE__),"compound.rb")
-#require File.join(File.dirname(__FILE__),"dataset.rb")
+require File.join(File.dirname(__FILE__),"dataset.rb")

data/lib/opentox.rb

@@ -4,7 +4,7 @@ $logger.level = Logger::DEBUG
 
 module OpenTox
 
-  attr_accessor :uri, :subjectid, :rdf, :response
+  attr_accessor :uri, :subjectid, :rdf, :response, :reload
 
   # Ruby interface
 
@@ -15,34 +15,34 @@ module OpenTox
   def initialize uri=nil, subjectid=nil
     @uri = uri.to_s.chomp
     @subjectid = subjectid
+    @reload = true
     @rdf = RDF::Graph.new
   end
 
   # Load metadata from service
   def pull
-    kind_of?(OpenTox::Dataset) ? uri = File.join(@uri,"metadata") : uri = @uri
     # TODO generic method for all formats
-    parse_rdfxml RestClientWrapper.get(uri,{},{:accept => $default_rdf, :subjectid => @subjectid})
+    parse_rdfxml RestClientWrapper.get(@uri,{},{:accept => $default_rdf, :subjectid => @subjectid})
   end
 
   # Get object metadata 
   # @return [Hash] Metadata
   def metadata 
-    pull if @rdf.empty?
-    metadata = {}
-    @rdf.query([RDF::URI.new(@uri),nil,nil]).collect do |statement|
-      metadata[statement.predicate] ||= []
-      metadata[statement.predicate] << statement.object
-    end
-    metadata
+    pull if @reload # force update
+    @rdf.to_hash[RDF::URI.new(@uri)]
   end
 
   # Get metadata values 
   # @param [RDF] Key from RDF Vocabularies
   # @return [Array] Values for supplied key
   def [](key)
-    pull if @rdf.empty?
-    @rdf.query([RDF::URI.new(@uri),key,nil]).collect{|statement| statement.object}
+    pull if @reload # force update
+    result = @rdf.query([RDF::URI.new(@uri),key,nil]).collect{|statement| statement.object}
+    # TODO: convert to OpenTox objects??
+    return nil if result and result.empty?
+    return result.first.to_s if result.size == 1 
+    return result.collect{|r| r.to_s}
+    result
   end
 
   # Save object at service
@@ -70,6 +70,14 @@ module OpenTox
     end
   end
 
+  def to_yaml
+    @rdf.to_hash.to_yaml
+  end
+
+  def to_json
+    to_hash.to_json
+  end
+
   # REST API
   def get headers={}
     headers[:subjectid] ||= @subjectid
@@ -125,10 +133,14 @@ module OpenTox
 
       # guess class from uri, this is potentially unsafe, but polling metadata from large uri lists is way too slow (and not all service provide RDF.type in their metadata)
       result = CLASSES.collect{|s| s if uri =~ /#{s.downcase}/}.compact
-      internal_server_error "Cannot determine class from URI: '#{uri}.\nCandidate classes are #{result.inspect}" unless result.size == 1
-      klass = result.first
+      if result.size == 1
+        klass = result.first
+      else
+        klass = OpenTox::Generic.new(uri)[RDF.type]
+        internal_server_error "Cannot determine class from URI '#{uri} (Candidate classes are #{result.inspect}) or matadata." unless klass
+      end
       # initialize with/without subjectid
-      subjectid ? eval("#{self}.new(\"#{uri}\", #{subjectid})") : eval("#{self}.new(\"#{uri}\")")
+      subjectid ? eval("#{self}.new(\"#{uri}\", \"#{subjectid}\")") : eval("#{self}.new(\"#{uri}\")")
     end
   end
 

data/lib/overwrite.rb

@@ -21,18 +21,22 @@ module URI
   def self.dataset? uri, subjectid=nil
     uri =~ /dataset/ and URI.accessible? uri, subjectid=nil
   end
- 
+
   def self.model? uri, subjectid=nil
     uri =~ /model/ and URI.accessible? uri, subjectid=nil
   end
 
-  def self.accessible? uri, subjectid=nil
+  def self.ssl? uri, subjectid=nil
+    URI.parse(uri).instance_of? URI::HTTPS
+  end
+
+  def self.accessible?(uri, subjectid=nil)
     if URI.task? uri or URI.compound? uri
       # just try to get a response, valid tasks may return codes > 400
       Net::HTTP.get_response(URI.parse(uri))
       true
     else
-      Net::HTTP.get_response(URI.parse(uri)).code.to_i < 400
+      Net::HTTP.get_response(URI.parse(uri + (subjectid ? "?subjectid=#{CGI.escape subjectid}" : ""))).code.to_i < 400
     end
   rescue
     false
@@ -64,27 +68,11 @@ module Kernel
       stdout = stdout_stream.read
       stderr = stderr_stream.read
     end
-    raise stderr.strip if !status.success?
+    internal_server_error "`" + cmd + "` failed.\n" + stdout + stderr if !status.success?
     return stdout
-  rescue Exception 
-    internal_server_error $!
+  rescue
+    internal_server_error $!.message
   end
 
-  alias_method :system!, :system
-
-  def system cmd
-    `#{cmd}`
-    return true
-  end
 end
 
-class Array
-  def short_backtrace
-    short = []
-    each do |c|
-      break if c =~ /sinatra\/base/
-      short << c
-    end
-    short.join("\n")
-  end
-end