opentox-client 0.0.2pre → 1.0.0pre1

data/lib/model.rb

@@ -6,8 +6,9 @@ module OpenTox
     # @param [Hash] params Parameters for OpenTox model
     # @param [optional,OpenTox::Task] waiting_task (can be a OpenTox::Subtask as well), progress is updated accordingly
     # @return [text/uri-list] Task or resource URI
-    def run params=nil
-      post params, {:accept => 'text/uri-list'}
+    def run params=nil, wait=true
+      uri = RestClientWrapper.post @uri, params, { :content_type => "text/uri-list", :subjectid => @subjectid}
+      wait_for_task uri if wait
     end
 
   end

data/lib/opentox-client.rb

@@ -2,34 +2,39 @@ require 'rubygems'
 require "bundler/setup"
 require 'rdf'
 require 'rdf/raptor'
+require 'rdf/n3'
 require "rest-client"
 require 'uri'
 require 'yaml'
 require 'json'
 require 'logger'
+require "securerandom"
 
 # define constants and global variables
 #TODO: switch services to 1.2
 RDF::OT =  RDF::Vocabulary.new 'http://www.opentox.org/api/1.2#'
 RDF::OT1 =  RDF::Vocabulary.new 'http://www.opentox.org/api/1.1#'
 RDF::OTA =  RDF::Vocabulary.new 'http://www.opentox.org/algorithmTypes.owl#'
+RDF::OLO =  RDF::Vocabulary.new 'http://purl.org/ontology/olo/core#'
 
-#CLASSES = ["Compound", "Feature", "Dataset", "Algorithm", "Model", "Validation", "Task", "ErrorReport", "Investigation"]
 CLASSES = ["Generic", "Compound", "Feature", "Dataset", "Algorithm", "Model", "Validation", "Task", "Investigation"]
 RDF_FORMATS = [:rdfxml,:ntriples,:turtle]
-$default_rdf = "application/rdf+xml"
 
 # Regular expressions for parsing classification data
 TRUE_REGEXP = /^(true|active|1|1.0|tox|activating|carcinogen|mutagenic)$/i
 FALSE_REGEXP = /^(false|inactive|0|0.0|low tox|deactivating|non-carcinogen|non-mutagenic)$/i
 
-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")
+[
+  "overwrite.rb",
+  "rest-client-wrapper.rb", 
+  "error.rb",
+  "authorization.rb", 
+  "policy.rb", 
+  "otlogger.rb", 
+  "opentox.rb",
+  "task.rb",
+  "compound.rb",
+  "dataset.rb",
+  "model.rb",
+].each{ |f| require File.join(File.dirname(__FILE__),f) }
+

data/lib/opentox.rb

@@ -4,7 +4,7 @@ $logger.level = Logger::DEBUG
 
 module OpenTox
 
-  attr_accessor :uri, :subjectid, :rdf, :response, :reload
+  attr_accessor :uri, :subjectid, :rdf
 
   # Ruby interface
 
@@ -13,134 +13,156 @@ module OpenTox
   # @param [optional,String] subjectid
   # @return [OpenTox] OpenTox object
   def initialize uri=nil, subjectid=nil
-    @uri = uri.to_s.chomp
-    @subjectid = subjectid
-    @reload = true
     @rdf = RDF::Graph.new
+    if uri
+      @uri = uri.to_s.chomp
+    else
+      service = self.class.to_s.split('::').last.downcase
+      service_uri = eval("$#{service}[:uri]")
+      bad_request_error "$#{service}[:uri] variable not set. Please set $#{service}[:uri] or use an explicit uri as first constructor argument " unless service_uri
+      @uri = File.join service_uri, SecureRandom.uuid
+    end
+    append RDF.type, eval("RDF::OT."+self.class.to_s.split('::').last)
+    append RDF::DC.date, DateTime.now
+    @subjectid = subjectid
   end
 
-  # Load metadata from service
-  def pull
-    # TODO generic method for all formats
-    parse_rdfxml RestClientWrapper.get(@uri,{},{:accept => $default_rdf, :subjectid => @subjectid})
-  end
-
-  # Get object metadata 
-  # @return [Hash] Metadata
+  # Object metadata 
+  # @return [Hash] Object metadata
   def metadata 
-    pull if @reload # force update
-    @rdf.to_hash[RDF::URI.new(@uri)]
+    # return plain strings instead of RDF objects
+    @rdf.to_hash[RDF::URI.new(@uri)].inject({}) { |h, (predicate, values)| h[predicate.to_s] = values.collect{|v| v.to_s}; h }
   end
 
-  # Get metadata values 
-  # @param [RDF] Key from RDF Vocabularies
-  # @return [Array] Values for supplied key
-  def [](key)
-    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
+  # Metadata values 
+  # @param [String] Predicate URI
+  # @return [Array, String] Predicate value(s)
+  def [](predicate)
+    return nil if metadata[predicate.to_s].nil?
+    metadata[predicate.to_s].size == 1 ? metadata[predicate.to_s].first : metadata[predicate.to_s]
   end
 
-  # Save object at service
-  def save
-    #TODO: dynamic assignment
-    post self.to_rdfxml, { :content_type => $default_rdf}
+  # Set object metadata
+  # @param [String] Predicate URI
+  # @param [Array, String] Predicate value(s)
+  def []=(predicate,values)
+    @rdf.delete [RDF::URI.new(@uri.to_s),RDF::URI.new(predicate.to_s),nil] 
+    append predicate.to_s, values
   end
 
-  RDF_FORMATS.each do |format|
-
-    # rdf parse methods for all formats e.g. parse_rdfxml
-    send :define_method, "parse_#{format}".to_sym do |rdf|
-      @rdf = RDF::Graph.new
-      RDF::Reader.for(format).new(rdf) do |reader|
-        reader.each_statement{ |statement| @rdf << statement }
-      end
+  def parameters
+    params = {}
+    query = RDF::Query.new({
+      :parameter => {
+        RDF.type  => RDF::OT.Parameter,
+        :property => :value,
+      }
+    })
+    query.execute(@rdf).each do |solution|
+      params[solution.parameter] = {} unless params[solution.parameter] 
+      params[solution.parameter][solution.property.to_s] = solution.value.to_s
     end
+    params.values
+  end
 
-    # rdf serialization methods for all formats e.g. to_rdfxml
-    send :define_method, "to_#{format}".to_sym do
-      rdf = RDF::Writer.for(format).buffer do |writer|
-        @rdf.each{|statement| writer << statement}
-      end
-      rdf
+  def parameters=(parameters)
+    parameters.each do |param|
+      p_node = RDF::Node.new
+      @rdf << [RDF::URI.new(@uri), RDF::OT.parameters, p_node]
+      @rdf << [p_node, RDF.type, RDF::OT.Parameter]
+      param.each{ |p,o| @rdf << [p_node, p, o] }
     end
   end
 
-  def to_yaml
-    @rdf.to_hash.to_yaml
+  # Append object metadata
+  # @param [String] Predicate URI
+  # @param [Array, String] Predicate value(s)
+  def append(predicate,values)
+    uri = RDF::URI.new @uri
+    predicate = RDF::URI.new predicate
+    [values].flatten.each { |value| @rdf << [uri, predicate, value] }
   end
 
-  def to_json
-    to_hash.to_json
+  # Get object from webservice
+  def get mime_type="text/plain"
+    response = RestClientWrapper.get(@uri,{},{:accept => mime_type, :subjectid => @subjectid})
+    if URI.task?(response)
+      wait_for_task response
+      response = RestClientWrapper.get(t.resultURI,{},{:accept => mime_type, :subjectid => @subjectid})
+    end
+    parse_ntriples response if mime_type == "text/plain"
+    parse_rdfxml response if mime_type == "application/rdf+xml"
   end
 
-  # REST API
-  def get headers={}
-    headers[:subjectid] ||= @subjectid
-    headers[:accept] ||= 'application/rdf+xml'
-    @response = RestClientWrapper.get @uri, {}, headers
+  # Post object to webservice
+  def post service_uri, wait=true
+    # TODO: RDFXML
+    uri = RestClientWrapper.post service_uri, to_ntriples, { :content_type => "text/plain", :subjectid => @subjectid}
+    wait_for_task uri if wait
   end
 
-  def post payload={}, headers={}
-    headers[:subjectid] ||= @subjectid
-    headers[:accept] ||= 'application/rdf+xml'
-    @response = RestClientWrapper.post(@uri.to_s, payload, headers)
+  # Save object at webservice
+  def put wait=true
+    # TODO: RDFXML
+    append RDF::DC.modified, DateTime.now
+    uri = RestClientWrapper.put @uri.to_s, self.to_ntriples, { :content_type => "text/plain", :subjectid => @subjectid}
+    wait_for_task uri if wait
   end
 
-  def put payload={}, headers={} 
-    headers[:subjectid] ||= @subjectid
-    headers[:accept] ||= 'application/rdf+xml'
-    @response = RestClientWrapper.put(@uri.to_s, payload, headers)
+  # Delete object at webservice
+  def delete 
+    RestClientWrapper.delete(@uri.to_s,nil,{:subjectid => @subjectid})
   end
 
-  def delete headers={}
-    headers[:subjectid] ||= @subjectid
-    @response = RestClientWrapper.delete(@uri.to_s,nil,headers)
+  def wait_for_task uri
+    if URI.task?(uri) 
+      t = OpenTox::Task.new uri
+      t.wait
+      unless t.completed?
+        #TODO raise correct error
+        #internal_server_error "Task #{uri} failed with #{$!.inspect}"
+      end
+      uri = t.resultURI
+    end
+    uri
   end
 
-  # class methods
-  module ClassMethods
+  RDF_FORMATS.each do |format|
 
-    def all service_uri, subjectid=nil
-      uris = RestClientWrapper.get(service_uri, {}, :accept => 'text/uri-list').split("\n").compact
-      uris.collect{|uri| URI.task?(service_uri) ? from_uri(uri, subjectid, false) : from_uri(uri, subjectid)}
+    # rdf parse methods for all formats e.g. parse_rdfxml
+    send :define_method, "parse_#{format}".to_sym do |rdf|
+      @rdf = RDF::Graph.new
+      RDF::Reader.for(format).new(rdf) do |reader|
+        reader.each_statement{ |statement| @rdf << statement }
+      end
     end
 
-    def create service_uri, subjectid=nil
-      uri = RestClientWrapper.post(service_uri, {}, {:accept => 'text/uri-list', :subjectid => subjectid})
-      URI.task?(service_uri) ? from_uri(uri, subjectid, false) : from_uri(uri, subjectid)
+    # rdf serialization methods for all formats e.g. to_rdfxml
+    send :define_method, "to_#{format}".to_sym do
+      RDF::Writer.for(format).buffer do |writer|
+        @rdf.each{|statement| writer << statement}
+      end
     end
+  end
 
-    def from_file service_uri, filename, subjectid=nil
-      file = File.new filename
-      from_uri RestClientWrapper.post(service_uri, {:file => file}, {:subjectid => subjectid, :content_type => file.mime_type, :accept => "text/uri-list"}), subjectid
+  def to_turtle # redefine to use prefixes (not supported by RDF::Writer)
+    prefixes = {:rdf => "http://www.w3.org/1999/02/22-rdf-syntax-ns#"}
+    ['OT', 'DC', 'XSD', 'OLO'].each{|p| prefixes[p.downcase.to_sym] = eval("RDF::#{p}.to_s") }
+    RDF::N3::Writer.for(:turtle).buffer(:prefixes => prefixes)  do |writer|
+      @rdf.each{|statement| writer << statement}
     end
+  end
 
-    private
-    def from_uri uri, subjectid=nil, wait=true
-        
-      uri.chomp!
-      # TODO add waiting task
-      if URI.task? uri and wait
-        t = OpenTox::Task.new(uri)
-        t.wait
-        uri = t.resultURI
-      end
-
-      # 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
-      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}\")")
+  {
+    :title => RDF::DC.title,
+    :dexcription => RDF::DC.description,
+    :type => RDF.type
+  }.each do |method,predicate|
+    send :define_method, method do 
+      self.[](predicate) 
+    end
+    send :define_method, "#{method}=" do |value|
+      self.[]=(predicate,value) 
     end
   end
 
@@ -148,7 +170,11 @@ module OpenTox
   CLASSES.each do |klass|
     c = Class.new do
       include OpenTox
-      extend OpenTox::ClassMethods
+
+      def self.all service_uri, subjectid=nil
+        uris = RestClientWrapper.get(service_uri, {}, :accept => 'text/uri-list').split("\n").compact
+        uris.collect{|uri| self.new(uri, subjectid)}
+      end
     end
     OpenTox.const_set klass,c
   end

data/lib/overwrite.rb

@@ -1,3 +1,21 @@
+class Object
+  # An object is blank if it's false, empty, or a whitespace string.
+  # For example, "", "   ", +nil+, [], and {} are all blank.
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+
+  def numeric?
+    true if Float(self) rescue false
+  end
+end
+
+module Enumerable
+  def duplicates
+    inject({}) {|h,v| h[v]=h[v].to_i+1; h}.reject{|k,v| v==1}.keys
+  end
+end
+
 class String
   def underscore
     self.gsub(/::/, '/').
@@ -68,11 +86,10 @@ module Kernel
       stdout = stdout_stream.read
       stderr = stderr_stream.read
     end
-    internal_server_error "`" + cmd + "` failed.\n" + stdout + stderr if !status.success?
+    internal_server_error "`" + cmd + "` failed.\n" + stdout + stderr unless status.success?
     return stdout
   rescue
-    internal_server_error $!.message
+    internal_server_error $!.message 
   end
 
 end
-

data/lib/policy.rb

@@ -58,7 +58,7 @@ module OpenTox
         when "guest", "anonymous" then "default_guest_policy"
         else "default_policy"
       end
-      xml = File.read(File.join(File.dirname(__FILE__), "templates/#{template}.xml"))
+      xml = get_xml_template(template)
       self.load_xml(xml)
       datestring = Time.now.strftime("%Y-%m-%d-%H-%M-%S-x") + rand(1000).to_s
 
@@ -78,6 +78,10 @@ module OpenTox
       return true
     end
 
+    def get_xml_template(template)
+      File.read(File.join(File.dirname(__FILE__), "templates/#{template}.xml"))
+    end
+
     #loads a xml template
     def load_xml(xml)
       rexml = REXML::Document.new(xml)
@@ -247,19 +251,22 @@ module OpenTox
     end
 
     # helper method sets value and type to opentox LDAP Distinguished Name (DN) of a user
+    # @param [String]Username set a username into LDAP DN
     def set_ot_user(username)
       self.value = "uid=#{username},ou=people,dc=opentox,dc=org"
       self.type = "LDAPUsers"
       true
     end
 
+    # @param [String]Username set a groupname into LDAP DN
     def set_ot_group(groupname)
       self.value = "cn=#{groupname},ou=groups,dc=opentox,dc=org"
       self.type = "LDAPGroups"
       true
     end
 
-    #rule inside a policy
+    # policyrule
+    # sets the permission for REST actions (GET, POST, PUT, DELETE) of a specific URI to allow/deny/nil
     class Rule
 
       attr_accessor :name, :uri, :get, :post, :put, :delete, :read, :readwrite
@@ -293,14 +300,18 @@ module OpenTox
         @put = check_value(value, @put)
       end
 
+      # read getter method
       def read
         return true if @get == "allow" && (@put == "deny" || !@put) && (@post == "deny" || !@post)
       end
 
+      # readwrite getter method
       def readwrite
         return true if @get == "allow" && @put == "allow" && @post == "allow"
       end
 
+      # Set(true case) or remove read(GET=allow) permissions.
+      # @param [Boolean]value (true,false)
       def read=(value)
         if value
           @get = "allow"; @put = nil; @post = nil
@@ -309,6 +320,8 @@ module OpenTox
         end
       end
 
+      # Set(true case) or remove readwrite(GET=allow,POST=allow,PUT=allow) permissions.
+      # @param [Boolean]value (true,false)
       def readwrite=(value)
         if value
           @get = "allow"; @put = "allow"; @post = "allow"
@@ -324,6 +337,8 @@ module OpenTox
       end
     end
 
+    # Subject of a policy
+    # name(subjectname), type('LDAPUsers' or 'LDAPGroups'), value(LDAP DN e.G.:'uid=guest,ou=people,dc=opentox,dc=org')
     class Subject
 
       attr_accessor :name, :type, :value