find_by_title() now generic

2 files changed, 41 insertions, 48 deletions

diff --git a/application.rb b/application.rb
index c6f2ccc..311224e 100644
--- a/application.rb
+++ b/application.rb
@@ -165,48 +165,23 @@ module OpenTox
           features = []
           ignored_feature_indices = []
           feature_names.each_with_index do |f,i|
-            feature_existing = OpenTox::Feature.find_by_title(f,{})
-            feature_new = OpenTox::Feature.new File.join($feature[:uri], SecureRandom.uuid)
-            feature_new[RDF::DC.title] = f
             values = table.collect{|row| val=row[i+1]; val.strip! unless val.nil?; val }.uniq.compact
             types = values.collect{|v| feature_type(v)}.uniq
-            if values.size == 0
-              # AM: 'Empty' feature
+            metadata = {} 
+            if values.size == 0 # empty feature
             elsif values.size <= 5 # max classes
-              feature_new.append RDF.type, [ RDF::OT.NominalFeature, RDF::OT.StringFeature ]
-              feature_new.append RDF::OT.acceptValue, values
+              metadata[RDF.type] = [ RDF::OT.NominalFeature, RDF::OT.StringFeature ]
+              metadata[RDF::OT.acceptValue] = values
             end
             if types.size == 1 and types[0] == RDF::OT.NumericFeature
-              feature_new.append RDF.type, RDF::OT.NumericFeature 
+              metadata[RDF.type] = [] unless metadata[RDF.type]
+              metadata[RDF.type] << RDF::OT.NumericFeature 
             else
-              feature_new.append RDF.type, [ RDF::OT.NominalFeature, RDF::OT.StringFeature ] # only nominal type for mixed cases
-              feature_new.append RDF::OT.acceptValue, values
-            end
-
-            # Check for equality of features
-            features_equal = true
-            if feature_new and feature_existing
-              [ RDF.type, RDF::OT.acceptValue ].each { |predicate|
-                unless (
-                  ( feature_new[predicate].nil? and
-                    feature_existing[predicate].nil? ) or
-                  ( feature_new[predicate] and
-                    feature_existing[predicate] and
-                    feature_new[predicate].sort == feature_existing[predicate].sort )
-                )
-                  features_equal = false
-                end
-              }
-            end
-
-            if features_equal
-              features << feature_existing
-              feature = feature_existing
-            else
-              features << feature_new
-              feature_new.put
-              feature = feature_new
+              metadata[RDF.type] = [ RDF::OT.NominalFeature, RDF::OT.StringFeature ] # only nominal type for mixed cases
+              metadata[RDF::OT.acceptValue] = values
             end
+            feature = OpenTox::Feature.find_by_title(f,metadata) # AM: find or generate
+            features << feature unless feature.nil?
             ntriples << "<#{feature.uri}> <#{RDF.type}> <#{RDF::OT.Feature}>."
             ntriples << "<#{feature.uri}> <#{RDF::OLO.index}> #{i} ."
           end
diff --git a/lib/utils/shims/feature.rb b/lib/utils/shims/feature.rb
index 43db600..1c11f40 100644
--- a/lib/utils/shims/feature.rb
+++ b/lib/utils/shims/feature.rb
@@ -16,23 +16,41 @@ module OpenTox
       f
     end
 
-    # Load a feature given its title. create it if not present, using metadata.
-    # When metadata is empty, nil is returned
+    # Load or create a feature given its title and metadata
+    # Create it if: a) not present, or b) present, but differs in metadata
+    # Newly created features are stored at the backend
     # @param[String] title Feature title
     # @param[Hash] metadata Feature metadata
-    # @return [OpenTox::Feature] Feature object with the full data, or nil, if not found
+    # @return [OpenTox::Feature] Feature object with the full data, or nil
     def self.find_by_title(title, metadata)
-      feature_uri = nil
+      metadata[RDF.type] << RDF::OT.Feature unless (metadata[RDF.type] and metadata[RDF.type].include?(RDF::OT.Feature))
+      metadata[RDF::DC.title] = title unless (metadata[RDF::DC.title] and metadata[RDF::DC.title].include?(title))
+      feature = feature_new = OpenTox::Feature.new File.join($feature[:uri], SecureRandom.uuid), @subjectid
+      feature_new.metadata = metadata
       sparql = "SELECT DISTINCT ?feature WHERE { ?feature <#{RDF.type}> <#{RDF::OT['feature'.capitalize]}>. ?feature <#{RDF::DC.title}> '#{title.to_s}' }"
-      feature_uri = OpenTox::Backend::FourStore.query(sparql,"text/uri-list").split("\n").first # is nil for non-existing feature
-      if feature_uri.nil? and metadata.size>0
-        feature = OpenTox::Feature.new feature_uri, @subjectid
-        feature.title = title
-        feature.metadata = metadata
-        feature.put
-      elsif feature_uri
-        feature = OpenTox::Feature.find(feature_uri, @subjectid)
-      end     
+      feature_uris = OpenTox::Backend::FourStore.query(sparql,"text/uri-list").split("\n")
+      features_equal = false # relevant also when no features found
+      feature_uris.each_with_index { |feature_uri,idx|
+        feature_existing = OpenTox::Feature.find(feature_uri, @subjectid)
+        if (feature_new.metadata.size+1 == feature_existing.metadata.size) # +1 due to title
+          features_equal = metadata.keys.collect { |predicate|
+            unless ( predicate == RDF::DC.title )
+              if feature_new[predicate].class == feature_existing[predicate].class
+                case feature_new[predicate].class.to_s
+                  when "Array" then (feature_new[predicate].sort == feature_existing[predicate].sort)
+                  else (feature_new[predicate] == feature_existing[predicate])
+                end
+              end
+            else
+              true
+            end
+          }.uniq == [true]
+        end
+        (feature=feature_existing and break) if features_equal
+      }
+      unless features_equal
+        feature_new.put 
+      end
       feature
     end