iqvoc 4.0.8 → 4.0.9

data/app/models/collection/member/base.rb

@@ -25,4 +25,16 @@ class Collection::Member::Base < ActiveRecord::Base
   belongs_to :collection, :class_name => 'Collection::Base'
   belongs_to :target, :class_name => 'Concept::Base'
 
+  def self.view_section(obj)
+    "main"
+  end
+
+  def self.view_section_sort_key(obj)
+    100
+  end
+
+  def self.partial_name(obj)
+    "partials/collection/member"
+  end
+
 end

data/app/models/collection/member/skos/base.rb

@@ -16,22 +16,23 @@
 
 class Collection::Member::SKOS::Base < Collection::Member::Base
 
-  self.rdf_namespace = "skos"
-  self.rdf_predicate = "member"
+  self.rdf_namespace = 'skos'
+  self.rdf_predicate = 'member'
 
-  def self.build_from_rdf(subject, predicate, object)
-    raise "Labeling::SKOS::Base#build_from_rdf: Subject (#{subject}) must be a Collection." unless subject.is_a?(Collection::Base)
-    raise "Labeling::SKOS::Base#build_from_rdf: Object (#{object}) must be a Collection or Concept." unless object.is_a?(Collection::Base) or object.is_a?(Concept::Base)
+  def self.build_from_rdf(rdf_subject, rdf_predicate, rdf_object)
+    raise "#{self.name}#build_from_rdf: Subject (#{rdf_subject}) must be a Collection."          unless rdf_subject.is_a?(Collection::Base)
+    raise "#{self.name}#build_from_rdf: Object (#{rdf_object}) must be a Collection or Concept." unless rdf_object.is_a?(Collection::Base) or rdf_object.is_a?(Concept::Base)
 
-    if subject.send(:members).select{|rel| rel.collection_id == subject.id || rel.target == object}.empty?
-      subject.send(:members) << self.new(:target => object)
-      if object.is_a?(Collection::Base)
-        subject.send(:subcollections) << object
-      end
+    member_instance = rdf_subject.members.select{|rel| rel.target == rdf_object}.first
+    if member_instance.nil?
+      predicate_class = Iqvoc::RDFAPI::PREDICATE_DICTIONARY[rdf_predicate] || self
+      member_instance = predicate_class.new(:target => rdf_object)
+      rdf_subject.members << member_instance
     end
 
-    if object.send(:collections).select{|coll| coll.id == subject.id}.empty?
-      object.send(:collections) << subject
+    if rdf_object.collections.select{|coll| coll.id == rdf_subject.id}.empty?
+      rdf_object.collections << rdf_subject
     end
+    member_instance
   end
 end

data/app/models/collection/skos/base.rb

@@ -19,7 +19,7 @@ class Collection::SKOS::Base < Collection::Base
   self.rdf_namespace = "skos"
   self.rdf_class = "Collection"
 
-  def build_rdf_subject(document, controller, &block)
+  def build_rdf_subject(&block)
     ns = IqRdf::Namespace.find_namespace_class(self.rdf_namespace)
     raise "Namespace '#{base_namespace}' is not defined in IqRdf document." unless ns
     subject = IqRdf.build_uri(self.origin, ns.build_uri(self.rdf_class), &block)

data/app/models/collection/{member/collection.rb → skos/unordered.rb}

@@ -14,20 +14,5 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-class Collection::Member::Collection < Collection::Member::Base
-
-  belongs_to :subcollection, :class_name => 'Collection::Base', :foreign_key => 'target_id'
-
-  def self.view_section(obj)
-    "main"
-  end
-
-  def self.view_section_sort_key(obj)
-    100
-  end
-
-  def self.partial_name(obj)
-    "partials/collection/member"
-  end
-
+class Collection::SKOS::Unordered < Collection::SKOS::Base
 end

data/app/models/collection/unordered.rb

@@ -14,5 +14,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+
 class Collection::Unordered < Collection::SKOS::Base
+
+  def initialize(*args)
+    ActiveSupport::Deprecation.warn("Collection::Unordered is deprecated. Use Collection::SKOS::Unordered instead.")
+    super
+  end
+
 end

data/app/models/concept/base.rb

@@ -27,19 +27,7 @@ class Concept::Base < ActiveRecord::Base
   self.rdf_namespace = nil
   self.rdf_class = nil
 
-  # ********** Validations
-
-  validates :origin, :presence => true, :on => :update
-
-  validate :ensure_distinct_versions, :on => :create
-
-  validate :ensure_a_pref_label_in_the_primary_thesaurus_language,
-    :on => :update
-
-  validate :ensure_no_pref_labels_share_the_same_language
-  validate :ensure_exclusive_top_term
-  validate :ensure_rooted_top_terms
-  validate :ensure_valid_rank_for_ranked_relations
+  include Concept::Validations
 
   Iqvoc::Concept.include_modules.each do |mod|
     include mod
@@ -63,9 +51,10 @@ class Concept::Base < ActiveRecord::Base
       labeling_class = reflection && reflection.class_name && reflection.class_name.constantize
       if labeling_class && labeling_class < Labeling::Base
         self.send(relation_name).all.map(&:destroy)
-        lang_values = {nil => lang_values.first} if lang_values.is_a?(Array) # For language = nil: <input name=bla[labeling_class][]> => Results in an Array!
-        lang_values.each do |lang, values|
-          values.split(Iqvoc::InlineDataHelper::Splitter).each do |value|
+        lang_values = { nil => lang_values.first } if lang_values.is_a?(Array) # For language = nil: <input name=bla[labeling_class][]> => Results in an Array! -- XXX: obsolete/dupe (cf `labelings_by_text=`)?
+        lang_values.each do |lang, inline_values|
+          lang = nil if lang.to_s == 'none'
+          Iqvoc::InlineDataHelper.parse_inline_values(inline_values).each do |value|
             value.squish!
             self.send(relation_name).build(:target => labeling_class.label_class.new(:value => value, :language => lang)) unless value.blank?
           end
@@ -85,7 +74,7 @@ class Concept::Base < ActiveRecord::Base
     # rankable: {'relation_name' => ['origin1:100', 'origin2:90']}
     (@concept_relations_by_id ||= {}).each do |relation_name, new_origins|
       # Split comma-separated origins and clean up parameter strings
-      new_origins = new_origins.split(Iqvoc::InlineDataHelper::Splitter).map(&:squish)
+      new_origins = new_origins.split(Iqvoc::InlineDataHelper::SPLITTER).map(&:squish)
 
       # Extract embedded ranks (if any) from origin strings (e.g. "origin1:100")
       # => { 'origin1' => nil, 'origin2' => 90 }
@@ -139,7 +128,7 @@ class Concept::Base < ActiveRecord::Base
   has_many :matches, :foreign_key => 'concept_id', :class_name => "Match::Base", :dependent => :destroy
   include_to_deep_cloning(:matches)
 
-  has_many :collection_members, :foreign_key => 'target_id', :class_name => "Collection::Member::Concept", :dependent => :destroy
+  has_many :collection_members, :foreign_key => 'target_id', :class_name => "Collection::Member::Base", :dependent => :destroy
   has_many :collections, :through => :collection_members, :class_name => Iqvoc::Collection.base_class_name
   include_to_deep_cloning(:collection_members)
 
@@ -300,18 +289,22 @@ class Concept::Base < ActiveRecord::Base
   def labelings_by_text=(hash)
     @labelings_by_text = hash
 
-     # For language = nil: <input name=bla[labeling_class][]> => Results in an Array!
-    @labelings_by_text.each do |relation_name, array_or_hash|
-      @labelings_by_text[relation_name] = {nil => array_or_hash.first} if array_or_hash.is_a?(Array)
+    @labelings_by_text.each do |relation_name, labels_by_lang|
+      # if `language` is `nil`, the respective HTML form field returns an array
+      # instead of a hash (`<input name=bla[labeling_class][]>`)
+      if labels_by_lang.is_a?(Array)
+        @labelings_by_text[relation_name] = { nil => labels_by_lang.first }
+      end
     end
 
     @labelings_by_text
   end
 
   def labelings_by_text(relation_name, language)
-    (@labelings_by_text && @labelings_by_text[relation_name] && @labelings_by_text[relation_name][language]) ||
-      self.send(relation_name).by_label_language(language).
-      map { |l| l.target.value }.join(Iqvoc::InlineDataHelper::Joiner)
+    (@labelings_by_text && @labelings_by_text[relation_name] &&
+        @labelings_by_text[relation_name][language]) ||
+        Iqvoc::InlineDataHelper.generate_inline_values(self.send(relation_name).
+            by_label_language(language).map { |l| l.target.value })
   end
 
   def concept_relations_by_id=(hash)
@@ -321,7 +314,7 @@ class Concept::Base < ActiveRecord::Base
   def concept_relations_by_id(relation_name)
     (@concept_relations_by_id && @concept_relations_by_id[relation_name]) ||
       self.send(relation_name).map { |l| l.target.origin }.
-      join(Iqvoc::InlineDataHelper::Joiner)
+      join(Iqvoc::InlineDataHelper::JOINER)
   end
 
   def concept_relations_by_id_and_rank(relation_name)
@@ -335,12 +328,12 @@ class Concept::Base < ActiveRecord::Base
   # If no prefLabel for the requested language exists, a new label will be returned
   # (if you modify it, don't forget to save it afterwards!)
   def pref_label
-    lang = I18n.locale.to_s
+    lang = I18n.locale.to_s == "none" ? nil : I18n.locale.to_s
     @cached_pref_labels ||= pref_labels.each_with_object({}) do |label, hash|
       if hash[label.language]
         Rails.logger.warn("Two pref_labels (#{hash[label.language]}, #{label}) for one language (#{label.language}). Taking the second one.")
       end
-      hash[label.language.to_s] = label
+      hash[label.language] = label
     end
     if @cached_pref_labels[lang].nil?
       # Fallback to the main language
@@ -354,12 +347,16 @@ class Concept::Base < ActiveRecord::Base
   def labels_for_labeling_class_and_language(labeling_class, lang = :en, only_published = true)
     # Convert lang to string in case it's not nil.
     # nil values play their own role for labels without a language.
-    lang = lang.to_s unless lang.nil?
+    if lang == "none"
+      lang = nil
+    elsif lang
+      lang = lang.to_s
+    end
     labeling_class = labeling_class.name if labeling_class < ActiveRecord::Base # Use the class name string
     @labels ||= labelings.each_with_object({}) do |labeling, hash|
       ((hash[labeling.class.name.to_s] ||= {})[labeling.target.language] ||= []) << labeling.target if labeling.target
     end
-    return ((@labels && @labels[labeling_class] && @labels[labeling_class][lang]) || []).select{|l| l.published? || !only_published}
+    ((@labels && @labels[labeling_class] && @labels[labeling_class][lang]) || []).select{|l| l.published? || !only_published}
   end
 
   def related_concepts_for_relation_class(relation_class, only_published = true)
@@ -416,82 +413,4 @@ class Concept::Base < ActiveRecord::Base
     }
   end
 
-  # ********** Validation methods
-
-  # validates that
-  # a) no more than one concept with the same origin already exists
-  # b) if a concept with the same origin exists, its publication state differs
-  #    from the to-be-saved one's
-  def ensure_distinct_versions
-    query = Concept::Base.by_origin(origin)
-    existing_total = query.count
-    if existing_total >= 2
-      errors.add :base, I18n.t("txt.models.concept.version_error")
-    elsif existing_total == 1
-      unless (query.published.count == 0 and published?) or
-             (query.published.count == 1 and not published?)
-        errors.add :base, I18n.t("txt.models.concept.version_error")
-      end
-    end
-  end
-
-  # top term and broader relations are mutually exclusive
-  def ensure_exclusive_top_term
-    if @full_validation
-      if top_term && broader_relations.any?
-        errors.add :base, I18n.t("txt.models.concept.top_term_exclusive_error")
-      end
-    end
-  end
-
-  # top terms must never be used as descendants (narrower relation targets)
-  # NB: for top terms themselves, this is covered by `ensure_exclusive_top_term`
-  def ensure_rooted_top_terms
-    if @full_validation
-      if narrower_relations.includes(:target). # XXX: inefficient?
-          select { |rel| rel.target && rel.target.top_term? }.any?
-        errors.add :base, I18n.t("txt.models.concept.top_term_rooted_error")
-      end
-    end
-  end
-
-  def ensure_a_pref_label_in_the_primary_thesaurus_language
-    if @full_validation
-      labels = pref_labels.select{|l| l.published?}
-      if labels.count == 0
-        errors.add :base, I18n.t("txt.models.concept.no_pref_label_error")
-      elsif not labels.map(&:language).map(&:to_s).include?(Iqvoc::Concept.pref_labeling_languages.first.to_s)
-        errors.add :base, I18n.t("txt.models.concept.main_pref_label_language_missing_error")
-      end
-    end
-  end
-
-  def ensure_no_pref_labels_share_the_same_language
-    # We have many sources a prefLabel can be defined in
-    pls = pref_labelings.map(&:target) +
-      send(Iqvoc::Concept.pref_labeling_class_name.to_relation_name).map(&:target) +
-      labelings.select{|l| l.is_a?(Iqvoc::Concept.pref_labeling_class)}.map(&:target)
-    languages = {}
-    pls.compact.each do |pref_label|
-      lang = pref_label.language.to_s
-      origin = (pref_label.origin || pref_label.id || pref_label.value).to_s
-      if (languages.keys.include?(lang) && languages[lang] != origin)
-        errors.add :pref_labelings, I18n.t("txt.models.concept.pref_labels_with_same_languages_error")
-      end
-      languages[lang] = origin
-    end
-  end
-
-  def ensure_valid_rank_for_ranked_relations
-    if @full_validation
-      relations.each do |relation|
-        if relation.class.rankable? && !(0..100).include?(relation.rank)
-          errors.add :base, I18n.t("txt.models.concept.invalid_rank_for_ranked_relations",
-            :relation => relation.class.model_name.human.downcase,
-            :relation_target_label => relation.target.pref_label.to_s)
-        end
-      end
-    end
-  end
-
 end

data/app/models/concept/relation/base.rb

@@ -71,6 +71,10 @@ class Concept::Relation::Base < ActiveRecord::Base
     self
   end
 
+  def self.bidirectional?
+    !!self.reverse_relation_class
+  end
+
   def self.view_section(obj)
     "relations"
   end

data/app/models/concept/relation/skos/base.rb

@@ -18,15 +18,25 @@ class Concept::Relation::SKOS::Base < Concept::Relation::Base
 
   self.rdf_namespace = 'skos'
 
-  def self.build_from_rdf(subject, predicate, object)
-    raise "Labeling::SKOS::Base#build_from_rdf: Subject (#{subject}) must be a Concept." unless subject.is_a?(Concept::Base)
-    raise "Labeling::SKOS::Base#build_from_rdf: Object (#{object}) must be a Concept." unless object.is_a?(Concept::Base)
+  def self.build_from_rdf(rdf_subject, rdf_predicate, rdf_object)
+    raise "#{self.name}#build_from_rdf: Subject (#{rdf_subject}) must be a Concept." unless rdf_subject.is_a? Concept::Base
+    raise "#{self.name}#build_from_rdf: Object (#{rdf_object}) must be a Concept."   unless rdf_object.is_a? Concept::Base
 
-    if subject.send(self.name.to_relation_name).select{|rel| rel.target_id == object.id || rel.target == object}.empty?
-      subject.send(self.name.to_relation_name) << self.new(:target => object)
+    relation_class = Iqvoc::RDFAPI::PREDICATE_DICTIONARY[rdf_predicate] || self
+
+    relation_instance = rdf_subject.send(self.name.to_relation_name).select{|rel| rel.target == rdf_object}
+    unless relation_instance
+      relation_instance = relation_class.new(:target => rdf_object)
+      rdf_subject.send(self.name.to_relation_name) << relation_instance
     end
-    if self.reverse_relation_class && object.send(self.reverse_relation_class.name.to_relation_name).select{|rel| rel.target_id == subject.id || rel.target == subject}.empty?
-      object.send(self.reverse_relation_class.name.to_relation_name) << self.reverse_relation_class.new(:target => subject)
+
+    if relation_class.bidirectional?
+      reverse_class      = relation_class.reverse_relation_class
+      reverse_collection = rdf_object.send(reverse_class.name.to_relation_name)
+      if reverse_collection.select{|rel| rel.target == rdf_subject}.empty?
+        reverse_instance = reverse_class.new(:target => rdf_subject)
+        reverse_collection << reverse_instance
+      end
     end
   end
 

data/app/models/concept/skos/base.rb

@@ -19,7 +19,7 @@ class Concept::SKOS::Base < Concept::Base
   self.rdf_namespace = "skos"
   self.rdf_class = "Concept"
 
-  def build_rdf_subject(document, controller, &block)
+  def build_rdf_subject(&block)
     ns = IqRdf::Namespace.find_namespace_class(self.rdf_namespace)
     raise "Namespace '#{self.rdf_namespace}' is not defined in IqRdf document." unless ns
     subject = IqRdf.build_uri(self.origin, ns.build_uri(self.rdf_class), &block)
@@ -32,4 +32,13 @@ class Concept::SKOS::Base < Concept::Base
     return subject
   end
 
+  # ********** Scopes
+  def self.expired(time = Time.now)
+    where(arel_table[:expired_at].lt(time))
+  end
+
+  def self.not_expired(time = Time.now)
+    col = arel_table[:expired_at]
+    where((col.eq(nil)).or(col.gteq(time)))
+  end
 end

data/app/models/concept/skos/scheme.rb

@@ -37,7 +37,7 @@ class Concept::SKOS::Scheme
     :scheme
   end
 
-  def build_rdf_subject(document, controller, &block)
+  def build_rdf_subject(&block)
     ns = IqRdf::Namespace.find_namespace_class(self.class.rdf_namespace.to_sym)
     raise "Namespace '#{rdf_namespace}' is not defined in IqRdf document." unless ns
     IqRdf.build_uri(origin, ns.build_uri(self.class.rdf_class), &block)

data/app/models/concept/validations.rb

@@ -0,0 +1,117 @@
+module Concept
+  module Validations
+    extend ActiveSupport::Concern
+
+    included do
+      validates :origin, :presence => true, :on => :update
+
+      validate :distinct_versions, :on => :create
+      validate :pref_label_in_primary_thesaurus_language, :on => :update
+      validate :unique_pref_label_language
+      validate :exclusive_top_term
+      validate :rooted_top_terms
+      validate :valid_rank_for_ranked_relations
+      validate :unique_pref_label
+    end
+
+    def distinct_versions
+      query = Concept::Base.by_origin(origin)
+      existing_total = query.count
+      if existing_total >= 2
+        errors.add :base, I18n.t("txt.models.concept.version_error")
+      elsif existing_total == 1
+        unless (query.published.count == 0 and published?) or
+               (query.published.count == 1 and not published?)
+          errors.add :base, I18n.t("txt.models.concept.version_error")
+        end
+      end
+    end
+
+    # top term and broader relations are mutually exclusive
+    def exclusive_top_term
+      if @full_validation
+        if top_term && broader_relations.any?
+          errors.add :base, I18n.t("txt.models.concept.top_term_exclusive_error")
+        end
+      end
+    end
+
+    # top terms must never be used as descendants (narrower relation targets)
+    # NB: for top terms themselves, this is covered by `ensure_exclusive_top_term`
+    def rooted_top_terms
+      if @full_validation
+        if narrower_relations.includes(:target). # XXX: inefficient?
+            select { |rel| rel.target && rel.target.top_term? }.any?
+          errors.add :base, I18n.t("txt.models.concept.top_term_rooted_error")
+        end
+      end
+    end
+
+    def pref_label_in_primary_thesaurus_language
+      if @full_validation
+        labels = pref_labels.select{|l| l.published?}
+        if labels.count == 0
+          errors.add :base, I18n.t("txt.models.concept.no_pref_label_error")
+        elsif not labels.map(&:language).map(&:to_s).include?(Iqvoc::Concept.pref_labeling_languages.first.to_s)
+          errors.add :base, I18n.t("txt.models.concept.main_pref_label_language_missing_error")
+        end
+      end
+    end
+
+    def unique_pref_label_language
+      # We have many sources a prefLabel can be defined in
+      pls = pref_labelings.map(&:target) +
+        send(Iqvoc::Concept.pref_labeling_class_name.to_relation_name).map(&:target) +
+        labelings.select{|l| l.is_a?(Iqvoc::Concept.pref_labeling_class)}.map(&:target)
+      languages = {}
+      pls.compact.each do |pref_label|
+        lang = pref_label.language.to_s
+        origin = (pref_label.origin || pref_label.id || pref_label.value).to_s
+        if (languages.keys.include?(lang) && languages[lang] != origin)
+          errors.add :pref_labelings, I18n.t("txt.models.concept.pref_labels_with_same_languages_error")
+        end
+        languages[lang] = origin
+      end
+    end
+
+    def unique_pref_label
+      if @full_validation
+        # checks if there are any existing pref labels with the same
+        # language and value
+        conflicting_pref_labels = pref_labels.select do |l|
+          Labeling::SKOS::PrefLabel.
+            joins(:owner, :target).
+            where(:labels => { :value => l.value, :language => l.language }).
+            where("labelings.owner_id != ?", id).
+            where("concepts.origin != ?", origin).
+            any?
+        end
+
+        if conflicting_pref_labels.any?
+          if conflicting_pref_labels.one?
+            errors.add :base,
+              I18n.t("txt.models.concept.pref_label_not_unique",
+                :label => conflicting_pref_labels.last.value)
+          else
+            errors.add :base,
+              I18n.t("txt.models.concept.pref_labels_not_unique",
+                :label => conflicting_pref_labels.map(&:value).join(", "))
+          end
+        end
+      end
+    end
+
+    def valid_rank_for_ranked_relations
+      if @full_validation
+        relations.each do |relation|
+          if relation.class.rankable? && !(0..100).include?(relation.rank)
+            errors.add :base, I18n.t("txt.models.concept.invalid_rank_for_ranked_relations",
+              :relation => relation.class.model_name.human.downcase,
+              :relation_target_label => relation.target.pref_label.to_s)
+          end
+        end
+      end
+    end
+
+  end
+end

data/app/models/label/base.rb

@@ -33,7 +33,8 @@ class Label::Base < ActiveRecord::Base
   # ********* Scopes
 
   def self.by_language(lang_code)
-    if (lang_code.is_a?(Array) && lang_code.include?(nil))
+    lang_code = nil if lang_code.to_s == "none"
+    if (lang_code.is_a?(Array) && lang_code.include?("none"))
       where(arel_table[:language].eq(nil).or(arel_table[:language].in(lang_code.compact)))
     elsif lang_code.blank?
       where(arel_table[:language].eq(nil))
@@ -93,8 +94,8 @@ class Label::Base < ActiveRecord::Base
   end
 
   def to_s
-    if language.to_s != I18n.locale.to_s.strip
-      value.to_s + " [#{I18n.t("txt.common.translation_missing_for")} '#{I18n.locale.to_s.strip}']"
+    if (language.presence || "none") != I18n.locale.to_s
+      value.to_s + " [#{I18n.t("txt.common.translation_missing_for")} '#{I18n.locale}']"
     else
       value.to_s
     end

data/app/models/labeling/skos/base.rb

@@ -28,6 +28,14 @@ class Labeling::SKOS::Base < Labeling::Base
     includes(:target).merge(self.label_class.where(:value => label, :language => language))
   end
 
+  def self.concept_expired
+    includes(:owner).merge(Iqvoc::Concept.base_class.expired)
+  end
+
+  def self.concept_not_expired
+    includes(:owner).merge(Iqvoc::Concept.base_class.not_expired)
+  end
+
   # ********** Methods
 
   def self.label_class
@@ -35,11 +43,11 @@ class Labeling::SKOS::Base < Labeling::Base
   end
 
   def self.partial_name(obj)
-    "partials/labeling/skos/base"
+    'partials/labeling/skos/base'
   end
 
   def self.edit_partial_name(obj)
-    "partials/labeling/skos/edit_base"
+    'partials/labeling/skos/edit_base'
   end
 
   def self.single_query(params = {})
@@ -54,10 +62,10 @@ class Labeling::SKOS::Base < Labeling::Base
     end
 
     if params[:collection_origin].present?
-      collection = Collection::Unordered.where(:origin => params[:collection_origin]).last
+      collection = Collection::Base.where(:origin => params[:collection_origin]).last
       if collection
         scope = scope.includes(:owner => :collection_members)
-        scope = scope.where("#{Collection::Member::Base.table_name}.collection_id" => collection)
+        scope = scope.where("#{Collection::Member::Base.table_name}.collection_id" => collection.id)
       else
         raise "Collection with Origin #{params[:collection_origin]} not found!"
       end
@@ -65,10 +73,10 @@ class Labeling::SKOS::Base < Labeling::Base
     scope = scope.includes(:owner)
 
     scope = case params[:for]
-    when "concept"
-      scope.where("concepts.type" => Iqvoc::Concept.base_class_name).merge(Concept::Base.published)
-    when "collection"
-      scope.where("concepts.type" => Iqvoc::Collection.base_class_name)
+    when 'concept'
+      scope.where('concepts.type' => Iqvoc::Concept.base_class_name).merge(Concept::Base.published)
+    when 'collection'
+      scope.where('concepts.type' => Iqvoc::Collection.base_class_name)
     else
       # no additional conditions
       scope
@@ -81,18 +89,21 @@ class Labeling::SKOS::Base < Labeling::Base
     'partials/labeling/skos/search_result'
   end
 
-  def self.build_from_rdf(subject, predicate, object)
-    raise "Labeling::SKOS::Base#build_from_rdf: Subject (#{subject}) must be a Concept." unless subject.is_a?(Concept::Base)
-    raise "Labeling::SKOS::Base#build_from_rdf: Object (#{object}) must be a string literal" unless object =~ /^"(.+)"(@(.+))?$/
+  def self.build_from_rdf(rdf_subject, rdf_predicate, rdf_object)
+    raise "#{self.name}#build_from_rdf: Subject (#{rdf_subject}) must be a Concept."     unless rdf_subject.is_a?(Concept::Base)
+    raise "#{self.name}#build_from_rdf: Object (#{rdf_object}) must be a string literal" unless rdf_object =~ /^"(.+)"(@(.+))?$/
 
     lang = $3
     value = JSON.parse(%Q{["#{$1}"]})[0].gsub("\\n", "\n") # Trick to decode \uHHHHH chars
 
-    subject.send(self.name.to_relation_name) << self.new(:target => self.label_class.new(:value => value, :language => lang))
+    predicate_class = Iqvoc::RDFAPI::PREDICATE_DICTIONARY[rdf_predicate] || self
+    predicate_class.new(:target => self.label_class.new(:value => value, :language => lang)).tap do |labeling|
+      rdf_subject.send(predicate_class.name.to_relation_name) << labeling
+    end
   end
 
   def build_rdf(document, subject)
-    subject.send(self.rdf_namespace.camelcase).send(self.rdf_predicate, target.to_s, :lang => target.language)
+    subject.send(self.rdf_namespace.camelcase).send(self.rdf_predicate, target.value.to_s, :lang => target.language)
   end
 
   def build_search_result_rdf(document, result)

data/app/models/match/skos/base.rb

@@ -1,13 +1,32 @@
+# encoding: UTF-8
+
+# Copyright 2011 innoQ Deutschland GmbH
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 class Match::SKOS::Base < Match::Base
 
   self.rdf_namespace = 'skos'
 
-  def self.build_from_rdf(subject, predicate, object)
-    raise "Note::SKOS::Base#build_from_rdf: Subject (#{subject}) must be able to recieve this kind of notes (#{self.name} => #{self.name.to_relation_name})." unless subject.class.reflections.include?(self.name.to_relation_name)
-    raise "Note::SKOS::Base#build_from_rdf: Object (#{object}) must be a URI" unless object =~ /^<(.+)>$/
+  def self.build_from_rdf(rdf_subject, rdf_predicate, rdf_object)
+    raise "#{self.class}#build_from_rdf: Subject (#{rdf_subject}) must be able to recieve this kind of match (#{self.name} => #{self.name.to_relation_name})." unless rdf_subject.class.reflections.include?(self.name.to_relation_name)
+    raise "#{self.class}#build_from_rdf: Object (#{rdf_object}) must be a URI" unless rdf_object =~ /^<(.+)>$/ # XXX: this assumes nt-format, right?
     uri = $1
 
-    subject.send(self.name.to_relation_name) << self.new(:value => uri)
+    match_class = Iqvoc::RDFAPI::PREDICATE_DICTIONARY[rdf_predicate] || self
+    match_class.new(:value => uri).tap do |match|
+      rdf_subject.send(self.name.to_relation_name) << match
+    end
   end
 
   def build_rdf(document, subject)
@@ -16,7 +35,7 @@ class Match::SKOS::Base < Match::Base
     if (IqRdf::Namespace.find_namespace_class(self.rdf_namespace.camelcase))
       subject.send(self.rdf_namespace.camelcase).send(self.rdf_predicate, URI.parse(value))
     else
-      raise "Match::SKOS::MappingRelation#build_rdf: couldn't find Namespace '#{self.rdf_namespace.camelcase}'."
+      raise "#{self.class}#build_rdf: couldn't find Namespace '#{self.rdf_namespace.camelcase}'."
     end
   end