opentox-ruby-api-wrapper 1.1.3 → 1.2.0

data/Rakefile

@@ -15,15 +15,11 @@ begin
 		gem.add_dependency "rack"
 		gem.add_dependency "rack-contrib"
 		gem.add_dependency "thin"
-		gem.add_dependency "ezmobius-redis-rb"
 		gem.add_dependency "emk-sinatra-url-for"
 		gem.add_dependency "cehoffman-sinatra-respond_to"
-		gem.add_dependency "dm-core"
-		gem.add_dependency "datamapper"
-		gem.add_dependency "do_sqlite3"
 		gem.add_development_dependency "cucumber"
 		gem.files =  FileList["[A-Z]*", "{bin,generators,lib,test}/**/*", 'lib/jeweler/templates/.gitignore']
-		gem.files.include %w(lib/tasks/opentox.rb, lib/tasks/redis.rb, lib/environment.rb, lib/algorithm.rb, lib/compound.rb, lib/dataset.rb, lib/feature.rb, lib/model.rb, lib/utils.rb, lib/templates/*)
+		gem.files.include %w(lib/tasks/owl.rb, lib/environment.rb, lib/algorithm.rb, lib/compound.rb, lib/dataset.rb, lib/model.rb, lib/utils.rb, lib/templates/*)
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
 	Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-1.1.3
+1.2.0

data/lib/algorithm.rb

@@ -1,35 +1,37 @@
 module OpenTox
 	module Algorithm 
 
-		class Fminer < OpenTox
-			# Create a new dataset with BBRC features
-			def self.create(params)
-				puts  params[:dataset_uri]
-				uri = RestClient.post File.join(@@config[:services]["opentox-algorithm"],'fminer'), :dataset_uri => params[:dataset_uri]
-				print "fminer finsihed "
-				puts uri
-				uri
-			end
-		end
+		class Fminer #< OpenTox
+			include Owl
 
-		class Similarity < OpenTox
-
-			def self.tanimoto(dataset1,compound1,dataset2,compound2)
-				RestClient.get File.join(@@config[:services]["opentox-algorithm"], 'tanimoto/dataset',dataset1.name,compound1.inchi,'dataset',dataset2.name,compound2.inchi)
+			def initialize
+				super
+				self.uri = File.join(@@config[:services]["opentox-algorithm"],'fminer')
+				self.title = "fminer"
+				self.source = "http://github.com/amaunz/libfminer"
+				self.parameters = {
+					"Dataset URI" => { :scope => "mandatory", :value => "dataset_uri" },
+					"Feature URI for dependent variable" => { :scope => "mandatory", :value => "feature_uri" }
+				}
 			end
-
-			def self.weighted_tanimoto(dataset1,compound1,dataset2,compound2)
-				# URI.escape does not work here
-				uri = File.join(@@config[:services]["opentox-algorithm"], 'weighted_tanimoto/dataset',CGI.escape(dataset1.name),'compound',CGI.escape(compound1.inchi),'dataset',CGI.escape(dataset2.name),'compound',CGI.escape(compound2.inchi))
-				RestClient.get uri
-			end
-
 		end
 
-		class Lazar < OpenTox
-			# Create a new prediction model from a dataset
-			def self.create(params)
-				RestClient.post File.join(@@config[:services]["opentox-algorithm"],"lazar_classification"), params
+		class Lazar #< OpenTox
+			include Owl
+
+			def initialize
+				super
+				self.uri = File.join(@@config[:services]["opentox-algorithm"],'lazar')
+				self.title = "lazar"
+				self.source = "http://github.com/helma/opentox-algorithm"
+				self.parameters = {
+					"Dataset URI" =>
+						{ :scope => "mandatory", :value => "dataset_uri" },
+					"Feature URI for dependent variable" =>
+						{ :scope => "mandatory", :value => "feature_uri" },
+					"Feature generation URI" =>
+						{ :scope => "mandatory", :value => "feature_generation_uri" }
+				}
 			end
 		end
 

data/lib/compound.rb

@@ -1,9 +1,8 @@
 module OpenTox
 
-	# uri: /compound/:inchi
-	class Compound < OpenTox
+	class Compound #< OpenTox
 
-		attr_reader :inchi
+		attr_reader :inchi, :uri
 
 		# Initialize with <tt>:uri => uri</tt>, <tt>:smiles => smiles</tt> or <tt>:name => name</tt> (name can be also an InChI/InChiKey, CAS number, etc)
 		def initialize(params)
@@ -14,8 +13,11 @@ module OpenTox
 			elsif params[:inchi]
 				@inchi = params[:inchi]
 				@uri = File.join(@@config[:services]["opentox-compound"],URI.escape(@inchi))
+			elsif params[:sdf]
+				@inchi = sdf2inchi(params[:sdf])
+				@uri = File.join(@@config[:services]["opentox-compound"],URI.escape(@inchi))
 			elsif params[:name]
-				@inchi = RestClient.get "#{@@cactus_uri}#{params[:name]}/stdinchi"
+				@inchi = RestClient.get("#{@@cactus_uri}#{params[:name]}/stdinchi").chomp
 				@uri = File.join(@@config[:services]["opentox-compound"],URI.escape(@inchi))
 			elsif params[:uri]
 				@inchi = params[:uri].sub(/^.*InChI/, 'InChI')
@@ -44,8 +46,12 @@ module OpenTox
 		end
 
 		# Match an array of smarts features, returns matching features
-		def match(smarts_dataset)
-			smarts_dataset.all_features.collect{ |uri| uri if self.match?(Feature.new(:uri => uri).name) }.compact
+		def match(smarts_array)
+			smarts_array.collect{|s| s if match?(s)}.compact
+		end
+
+		def sdf2inchi(sdf)
+			obconversion(sdf,'sdf','inchi')
 		end
 
 		def smiles2inchi(smiles)
@@ -61,7 +67,12 @@ module OpenTox
 			obmol = OpenBabel::OBMol.new
 			obconversion.set_in_and_out_formats input_format, output_format
 			obconversion.read_string obmol, identifier
-			obconversion.write_string(obmol).gsub(/\s/,'').chomp
+			case output_format
+			when /smi|can|inchi/
+				obconversion.write_string(obmol).gsub(/\s/,'').chomp
+			else
+				obconversion.write_string(obmol)
+			end
 		end
 	end
 end

data/lib/dataset.rb

@@ -1,79 +1,184 @@
 module OpenTox
 
-	# key: /datasets
-	# set: dataset uris
-	# key: /dataset/:dataset/compounds
-	# set: compound uris
-	# key: /dataset/:dataset/compound/:inchi
-	# set: feature uris
-	class Dataset < OpenTox
+	class Dataset 
+		include Owl
 
-		# Initialize with <tt>:uri => uri</tt> or <tt>:name => name</tt> (creates a new dataset)
-		def initialize(uri)
-			super(uri)
+		#attr_accessor :model
+
+		def initialize 
+			super
 		end
 
-		def self.create(params)
-			uri = RestClient.post @@config[:services]["opentox-dataset"], :name => params[:name]
-			Dataset.new(uri.to_s)
+		# find or create a new compound and return the resource
+		def find_or_create_compound(uri)
+			compound = @model.subject(DC["identifier"], uri)
+			if compound.nil?
+				compound = @model.create_resource
+				@model.add compound, RDF['type'], OT["Compound"]
+				@model.add compound, DC["identifier"], uri
+			end
+			compound
 		end
 
-		def self.find(params)
-			begin
-				if params[:name]
-					uri = File.join(@@config[:services]["opentox-dataset"], URI.encode(params[:name]))
-				elsif params[:uri]
-					uri = params[:uri]
-				end
-				RestClient.get uri # check if the resource is available
-				Dataset.new(uri) if uri
-			rescue
-				nil
+		# find or create a new feature and return the resource
+		def find_or_create_feature(f)
+			feature = @model.subject(DC["title"], f[:name].to_s)
+			if feature.nil?
+				feature = @model.create_resource
+				@model.add feature, RDF['type'], OT["Feature"]
+				@model.add feature, DC["identifier"], File.join("feature",feature.to_s.gsub(/[()]/,'')) # relative uri as we don know the final uri
+				@model.add feature, DC["title"], f[:name].to_s
+				@model.add feature, OT['hasSource'], f[:source].to_s if f[:source]
 			end
+			feature
 		end
 
-		def self.find_or_create(params)
-			self.create(params) unless self.find(params)
+		# find or create a new value and return the resource
+		def find_or_create_value(v)
+			value = @model.subject OT["value"], v.to_s
+			if value.nil?
+				value = @model.create_resource
+				@model.add value, RDF['type'], OT["FeatureValue"]
+				@model.add value, OT["value"], v.to_s
+			end
+			value
 		end
 
-		def self.base_uri
-			@@config[:services]["opentox-dataset"]
+		def tuple?(t)
+			statements = []
+			has_tuple = true
+			t.each do |name,v|
+				feature = self.find_or_create_feature(:name => name)
+				value = self.find_or_create_value(v)
+				tuple = @model.subject(feature,value)
+				has_tuple = false if tuple.nil?
+				statements << [tuple,feature,value]
+			end
+			tuples_found = statements.collect{|s| s[0]}.uniq
+			has_tuple = false unless tuples_found.size == 1
+			has_tuple
 		end
 
-		def import(params)
-			if params[:csv]
-				# RestClient seems not to work for file uploads
-				#RestClient.post @uri + '/import', :compound_format => params[:compound_format], :content_type => "text/csv", :file => File.new(params[:csv])
-				`curl -X POST -F "file=@#{params[:csv]};type=text/csv" -F compound_format=#{params[:compound_format]} #{@uri + '/import'}`
+		def create_tuple(t)
+			tuple = @model.create_resource
+			@model.add tuple, RDF['type'], OT["Tuple"]
+			t.each do |name,value|
+				feature = self.find_or_create_feature(:name => name)
+				value = self.find_or_create_value(value)
+				pair = @model.create_resource
+				@model.add tuple, OT['tuple'], pair
+				@model.add pair, OT['feature'], feature
+				@model.add pair, OT['value'], value
 			end
+			tuple
 		end
 
-		def add(features)
-			RestClient.put @uri, :features => features
+		def find_or_create_tuple(t)
+			if self.tuple?(t)
+				t 
+			else
+				self.create_tuple(t)
+			end
 		end
 
-		# Get all compounds from a dataset
-		def compound_uris
-			RestClient.get(File.join(@uri, 'compounds')).split("\n")
+		def add_data_entry(compound,feature,value)
+			data_entry = @model.create_resource
+			@model.add data_entry, RDF['type'], OT["DataEntry"]
+			@model.add data_entry, OT['compound'], compound
+			@model.add data_entry, OT['feature'], feature
+			@model.add data_entry, OT['values'], value
 		end
 
-		def compounds
-			compound_uris.collect{|uri| Compound.new(:uri => uri)}
+		def self.create(data, content_type = 'application/rdf+xml')
+			uri = RestClient.post @@config[:services]["opentox-dataset"], data, :content_type => content_type
+			dataset = Dataset.new
+			dataset.read uri.to_s
+			dataset
+		end
+
+		def self.find(uri)
+			begin
+				RestClient.get uri # check if the resource is available
+				dataset = Dataset.new
+				dataset.read uri.to_s
+				dataset
+			rescue
+				nil
+			end
+		end
+
+		def features
 		end
 
-		# Get all features for a compound
-		def feature_uris(compound)
-			uri = File.join(@uri, 'compound', CGI.escape(compound.inchi)) # URI.encode does not work here
-			RestClient.get(uri).split("\n")
+		def feature_values(uri)
+			features = {}
+			feature = @model.subject(DC["identifier"],uri)
+			@model.subjects(RDF['type'], OT["Compound"]).each do |compound_node|
+				compound = @model.object(compound_node,  DC["identifier"]).to_s.sub(/^\[(.*)\]$/,'\1')
+				features[compound] = [] unless features[compound]
+				@model.subjects(OT['compound'], compound_node).each do |data_entry|
+					if feature == @model.object(data_entry, OT['feature'])
+						values_node = @model.object(data_entry, OT['values'])
+						@model.find(values_node, OT['value'], nil) do |s,p,value| 
+							case value.to_s
+							when "true"
+								features[compound] << true
+							when "false"
+								features[compound] << false
+							else
+								features[compound] << value.to_s
+							end
+						end
+					end
+				end
+			end
+			features
 		end
 
-		# Get all features for a compound
-		def features(compound)
-			feature_uris(compound).collect{|uri| Feature.new(:uri => uri)}
+		def tuples
+			tuples = []
+			@model.subjects(RDF['type'], OT["Tuple"]).each do |t|
+				tuple = {}
+				compounds = []
+				@model.subjects(OT['values'], t).each do |data_entry|
+					compound_node = @model.object(data_entry,OT['compound'])
+					compounds << @model.object(compound_node,  DC["identifier"]).to_s
+				end
+				@model.find(t, OT['tuple'],nil) do |s,p,pair|
+					feature_node = @model.object(pair, OT['feature'])
+					feature_name = @model.object(feature_node, DC['title']).to_s
+					value_node = @model.object(pair, OT['value'])
+					value = @model.object(value_node, OT['value']).to_s
+					value = value.to_f if value.match(/^[\d\.]+$/)
+					tuple[feature_name.to_sym] = value
+				end
+				tuple[:compounds] = compounds
+				tuples << tuple
+			end
+			tuples
 		end
 
-		def all_features
-			RestClient.get(File.join(@uri, 'features')).split("\n")
+		def tuple(compound_uri)
+			compound_node = @model.subject(DC["identifier"],compound_uri)
+			#puts compound_uri
+			@model.subjects(OT['compound'], compound_node).each do |data_entry|
+				values_node = @model.object(data_entry, OT['values'])
+				@model.find(values_node, OT['tuple'], nil) do |s,p,tuple| 
+					@model.find(tuple, OT['feature'], nil) do |s,p,feature|
+						name = @model.object(feature,DC['title']).to_s
+						#puts name
+					end
+				end
+				#puts values_node
+			end
+		end
+
+		def compounds
+			compounds = []
+			@model.subjects(RDF['type'], OT["Compound"]).each do |compound_node|
+				compounds << @model.object(compound_node,  DC["identifier"])#.to_s.sub(/^\[(.*)\]$/,'\1')
+			end
+			compounds
 		end
 
 		# Delete a dataset
@@ -81,14 +186,64 @@ module OpenTox
 			RestClient.delete @uri
 		end
 
-		def tanimoto(dataset)
-			RestClient.get(File.join(@uri,'tanimoto',dataset.path))
-		end
-
-		def weighted_tanimoto(dataset)
-			RestClient.get(File.join(@uri,'weighted_tanimoto',dataset.path))
+		def save
+			RestClient.post(@@config[:services]["opentox-dataset"], self.rdf, :content_type =>  "application/rdf+xml").to_s
 		end
 
 	end
 
 end
+
+
+#		def tanimoto(dataset)
+#			RestClient.get(File.join(@uri,'tanimoto',dataset.path))
+#		end
+#
+#		def weighted_tanimoto(dataset)
+#			RestClient.get(File.join(@uri,'weighted_tanimoto',dataset.path))
+#		end
+=begin
+		def data_entries
+			data = {}
+			@model.subjects(RDF['type'], OT["Compound"]).each do |compound_node|
+				compound = @model.object(compound_node,  DC["identifier"]).to_s#.sub(/^\[(.*)\]$/,'\1')
+				#compound = OpenTox::Compound.new(:inchi => compound).smiles
+				data[compound] = [] unless data[compound]
+				#puts compound
+				@model.subjects(OT['compound'], compound_node).each do |data_entry|
+					feature_node = @model.object(data_entry, OT['feature'])
+					feature = @model.object(feature_node,  DC["identifier"]).to_s
+					values_node = @model.object(data_entry, OT['values'])
+					type = @model.object(values_node,RDF['type']).to_s
+					case type
+					when /FeatureValue/
+						@model.find(values_node, OT['value'], nil) do |s,p,value| 
+							case value.to_s
+							when "true"
+								data[compound] << {feature => true}
+							when "false"
+								data[compound] << {feature => false}
+							else
+								data[compound] << {feature => value.to_s}
+							end
+						end
+					when /Tuple/ # this is really slow
+						t = {}
+						@model.find(values_node, OT['tuple'], nil) do |s,p,tuple| 
+							@model.find(tuple, OT['feature'], nil) do |s,p,feature|
+								@name = @model.object(feature,DC['title']).to_s
+							end
+							@model.find(tuple, OT['value'], nil) do |s,p,value|
+								v = @model.object(value,OT['value']).to_s
+								t[@name] = v
+								#print @name + ": "
+								#puts v
+							end
+						end
+						data[compound] << t
+					end
+				end
+			end
+			data
+		end
+=end

data/lib/environment.rb

@@ -17,7 +17,14 @@ else
 	exit
 end
 
+# RDF namespaces
+RDF = Redland::Namespace.new 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'
+OWL = Redland::Namespace.new 'http://www.w3.org/2002/07/owl#'
+DC = Redland::Namespace.new 'http://purl.org/dc/elements/1.1/'
+OT = Redland::Namespace.new 'http://www.opentox.org/api/1.1#'
+
 # configure redis database
+=begin
 begin
 	case ENV['RACK_ENV']
 	when 'production'
@@ -31,3 +38,4 @@ begin
 rescue
 	puts "Redis database not running, please start it with 'rake redis:start'."
 end
+=end

data/lib/feature.rb

@@ -1,11 +1,10 @@
 module OpenTox
 
-	# uri: /feature/:name/:property_name/:property_value/...
-	class Feature < OpenTox
+	class Feature 
+		include Owl
 
-		attr_accessor :name, :values
+		def self.find_or_create(feature)
 
-		def initialize(params)
 			if params[:uri]
 				@uri = params[:uri]
 				items = URI.split(@uri)[5].split(/\//)

data/lib/model.rb

@@ -1,38 +1,69 @@
 module OpenTox
-
-	module Model 
-
-		class LazarClassification < OpenTox
-
+	module Model
+		class Lazar
+			include Owl
+			
 			# Create a new prediction model from a dataset
-			def initialize(uri)
-				super(uri)
+			def initialize
+				super
 			end
 
-			def self.create(params)
-				uri = RestClient.post File.join(@@config[:services]["opentox-model"], 'lazar_classification'), params
-				puts "URI: " + uri
-				LazarClassification.new(uri.to_s)
+			def read_yaml(id,yaml)
+				@lazar = YAML.load yaml
+				self.identifier = File.join(@@config[:services]["opentox-model"],'lazar',id)
+				self.title = "lazar model for #{@lazar[:endpoint]}"
+				self.source = "http://github.com/helma/opentox-model"
+				self.parameters = {
+					"Dataset URI" => { :scope => "mandatory", :value => "dataset_uri=#{@lazar[:activity_dataset]}" },
+					"Feature URI for dependent variable" => { :scope => "mandatory", :value => "feature_uri=#{@lazar[:endpoint]}" },
+					"Feature generation URI" => { :scope => "mandatory", :value => "feature_generation_uri=" } #TODO write to yaml
+				}
+				self.algorithm = File.join(@@config[:services]["opentox-model"],"lazar")
+				self.trainingDataset = @lazar[:activity_dataset]
+				self.dependentVariables = @lazar[:endpoint]
+				self.predictedVariables = @lazar[:endpoint] + " lazar prediction"
 			end
 
-			def self.find(name)
-				uri = RestClient.get File.join(@@config[:services]["opentox-model"], 'lazar_classification', URI.encode(params[:name]))
-				LazarClassification.new(uri)
+			def self.find(uri)
+				begin
+					YAML.load(RestClient.get uri)
+					Lazar.new uri
+				rescue
+					halt 404, "Model #{uri} not found."
+				end
 			end
 
 			def self.find_all
-				RestClient.get File.join(@@config[:services]["opentox-model"], 'lazar_classification')#.split("\n")
+				RestClient.get(@@config[:services]["opentox-model"]).split("\n")
 			end
-
+			
 			# Predict a compound
 			def predict(compound)
-				LazarPrediction.new(:uri => RestClient.post(@uri, :compound_uri => compound.uri))
+				RestClient.post(@uri, :compound_uri => compound.uri)
 			end
 
 			def self.base_uri
 				@@config[:services]["opentox-model"]
 			end
 
+			def self.create(data)
+				RestClient.post(@@config[:services]["opentox-model"], data, :content_type => "application/x-yaml").to_s
+			end
+
+			def endpoint
+				YAML.load(RestClient.get uri)[:endpoint]
+			end
+
+		end
+	end
+
+
+=begin
+	module Model 
+
+		class LazarClassification < OpenTox
+
+
 		end
 
 	end
@@ -48,11 +79,11 @@ module OpenTox
 				end
 
 				def classification
-					YAML.load(RestClient.get @uri)[:classification]
+					YAML.load(RestClient.get(@uri))[:classification]
 				end
 
 				def confidence
-					YAML.load(RestClient.get @uri)[:confidence]
+					YAML.load(RestClient.get(@uri))[:confidence]
 				end
 
 				def neighbors
@@ -68,4 +99,5 @@ module OpenTox
 		end
 
 	end
+=end
 end

data/lib/opentox-ruby-api-wrapper.rb

@@ -1,4 +1,4 @@
-['rubygems', 'sinatra', 'sinatra/url_for',  'redis','builder', 'rest_client', 'yaml', 'cgi', 'spork', 'environment'].each do |lib|
+['rubygems', 'sinatra', 'sinatra/url_for', 'rest_client', 'yaml', 'cgi', 'spork', 'redland', 'rdf/redland', 'rdf/redland/util', 'environment'].each do |lib|
 	require lib
 end
 
@@ -8,6 +8,6 @@ rescue LoadError
 	puts "Please install Openbabel with 'rake openbabel:install' in the compound component"
 end
 
-['opentox', 'compound','feature','dataset','algorithm','model','task','utils'].each do |lib|
+['owl', 'compound','dataset','algorithm','model','task','utils'].each do |lib|
 	require lib
 end

data/lib/owl.rb

@@ -0,0 +1,102 @@
+module OpenTox
+
+	module Owl
+
+		attr_reader :uri, :model
+
+		def initialize
+
+			@model = Redland::Model.new Redland::MemoryStore.new
+			@parser = Redland::Parser.new
+			@serializer = Redland::Serializer.ntriples
+			
+			# explicit typing
+			# this should come from http://opentox.org/data/documents/development/RDF%20files/OpenToxOntology/at_download/file (does not pass OWL-DL validation)
+			@model.add @uri, RDF['type'], OWL['Ontology']
+			# annotation properties
+			@model.add DC['source'], RDF['type'], OWL["AnnotationProperty"]
+			@model.add DC['identifier'], RDF['type'], OWL["AnnotationProperty"]
+			@model.add DC['title'], RDF['type'], OWL["AnnotationProperty"]
+			# object properties
+			@model.add OT['feature'], RDF['type'], OWL["ObjectProperty"]
+			@model.add OT['compound'], RDF['type'], OWL["ObjectProperty"]
+			@model.add OT['values'], RDF['type'], OWL["ObjectProperty"]
+			@model.add OT['tuple'], RDF['type'], OWL["ObjectProperty"] # added by ch
+			@model.add OT['parameters'], RDF['type'], OWL["ObjectProperty"]
+			# datatype properties
+			@model.add OT['value'], RDF['type'], OWL["DatatypeProperty"]
+			@model.add OT['paramValue'], RDF['type'], OWL["DatatypeProperty"]
+			@model.add OT['paramScope'], RDF['type'], OWL["DatatypeProperty"]
+			@model.add OT['hasSource'], RDF['type'], OWL["DatatypeProperty"]
+			# classes
+			@model.add OT['Dataset'], RDF['type'], OWL["Class"]
+			@model.add OT['FeatureValue'], RDF['type'], OWL["Class"]
+			@model.add OT['Tuple'], RDF['type'], OWL["Class"] # added by ch
+			@model.add OT['Feature'], RDF['type'], OWL["Class"]
+			@model.add OT['Compound'], RDF['type'], OWL["Class"]
+			@model.add OT['DataEntry'], RDF['type'], OWL["Class"]
+			@model.add OT['Parameter'], RDF['type'], OWL["Class"]
+			@model.add OT['Algorithm'], RDF['type'], OWL["Class"]
+		end
+
+		def owl_class
+			self.class.to_s.sub(/^OpenTox::/,'')
+			#@model.subject RDF['type'], OT[self.class.to_s.sub(/^OpenTox::/,'')]
+		end
+
+		def read(uri)
+			@parser.parse_into_model(@model,uri)
+			@uri = uri
+		end
+
+		def rdf=(rdf)
+			@uri = '/' unless @uri
+			@parser.parse_string_into_model(@model,rdf,@uri)
+		end
+
+		def rdf
+			@model.to_string
+		end
+
+		def uri=(uri)
+			identifier = uri
+		end
+
+		def to_ntriples
+			@serializer.model_to_string(Redland::Uri.new(@uri), @model)
+		end
+
+		def title
+			puts OT[self.owl_class]
+			@model.object(OT[self.owl_class], DC['title']).to_s
+		end
+
+		def parameters=(params)
+			params.each do |name, settings|
+				parameter = @model.create_resource
+				@model.add parameter, RDF['type'], OT['Parameter']
+				@model.add parameter, DC['title'], name
+				@model.add parameter, OT['paramScope'], settings[:scope]
+				@model.add parameter, OT['paramValue'],  settings[:value]
+			end
+		end
+
+		def create_owl_statement(name,value)
+			r = @model.create_resource
+			@model.add r, RDF['type'], DC[name.gsub(/^[a-z]/) { |a| a.upcase }] # capitalize only the first letter
+			@model.add r, DC[name], value
+		end
+
+		def method_missing(name, *args)
+			# create magic setter methods
+			if /=/ =~ name.to_s
+			puts "create_owl_statement #{name.to_s.sub(/=/,'')}, #{args.first}"
+				create_owl_statement name.to_s.sub(/=/,''), args.first
+			else
+				raise "No method #{name}"
+			end
+		end
+
+	end
+
+end

data/lib/task.rb

@@ -1,15 +1,16 @@
 module OpenTox
 
-	class Task < OpenTox
-		#private :new
+	class Task #< OpenTox
 
 		def initialize(uri)
 			super(uri)
 		end
 
-		def self.create(params)
-			uri = RestClient.post @@config[:services]["opentox-task"], :resource_uri => params[:resource_uri]
-			Task.new uri
+		#def self.create(uri)
+		def self.create
+			puts @@config[:services]["opentox-task"]
+			uri = RestClient.post @@config[:services]["opentox-task"], ''#, :dataset_uri => uri
+			Task.new(uri)
 		end
 
 		def self.find(params)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: opentox-ruby-api-wrapper
 version: !ruby/object:Gem::Version 
-  version: 1.1.3
+  version: 1.2.0
 platform: ruby
 authors: 
 - Christoph Helma
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-17 00:00:00 +01:00
+date: 2009-12-16 00:00:00 +01:00
 default_executable: opentox-install-debian.sh
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -62,16 +62,6 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
     version: 
-- !ruby/object:Gem::Dependency 
-  name: ezmobius-redis-rb
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
 - !ruby/object:Gem::Dependency 
   name: emk-sinatra-url-for
   type: :runtime
@@ -92,36 +82,6 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
     version: 
-- !ruby/object:Gem::Dependency 
-  name: dm-core
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: datamapper
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: do_sqlite3
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
 - !ruby/object:Gem::Dependency 
   name: cucumber
   type: :development
@@ -155,7 +115,7 @@ files:
 - lib/helper.rb
 - lib/model.rb
 - lib/opentox-ruby-api-wrapper.rb
-- lib/opentox.rb
+- lib/owl.rb
 - lib/spork.rb
 - lib/task.rb
 - lib/tasks/opentox.rb

data/lib/opentox.rb

@@ -1,27 +0,0 @@
-module OpenTox
-
-	class OpenTox
-		attr_accessor :uri
-
-		def initialize(uri)
-			@uri = uri
-		end
-
-		# Get the object name
-		def name
-			RestClient.get @uri + '/name'
-		end
-
-		# Deletes an object
-		def destroy
-			RestClient.delete @uri
-		end
-
-		# Object path without hostname
-		def path
-			URI.split(@uri)[5]
-		end
-
-	end
-
-end