iqvoc 4.7.0 → 4.8.0

data/app/controllers/hierarchy_controller.rb

@@ -113,6 +113,7 @@ class HierarchyController < ApplicationController
 
     scope = Iqvoc::Concept.base_class
     scope = include_unpublished ? scope.editor_selectable : scope.published
+    scope = scope.ordered_by_pref_label
 
     # validate depth parameter
     if not depth
@@ -176,7 +177,8 @@ class HierarchyController < ApplicationController
 
     rels = scope.where(Concept::Relation::Base.arel_table[:target_id].
         eq(root_concept.id)).references(:concept_relations)
-    return rels.inject({}) do |memo, concept|
+
+    results = rels.inject({}) do |memo, concept|
       if include_siblings
         determine_siblings(concept).each { |sib| memo[sib] = {} }
       end
@@ -184,12 +186,14 @@ class HierarchyController < ApplicationController
           current_depth, include_siblings)
       memo
     end
+
+    results
   end
 
   # NB: includes support for poly-hierarchies -- XXX: untested
   def determine_siblings(concept)
-    return concept.broader_relations.map do |rel|
+    concept.broader_relations.map do |rel|
       rel.target.narrower_relations.map { |rel| rel.target } # XXX: expensive
-    end.flatten.uniq
+    end.flatten.uniq.sort { |a, b| a.pref_label <=> b.pref_label }
   end
 end

data/app/controllers/instance_configuration_controller.rb

@@ -69,7 +69,7 @@ class InstanceConfigurationController < ApplicationController
 
   # default value determines value type
   def serialize(value, default_value)
-    Iqvoc::InstanceConfiguration.validate_value(value)
+    Iqvoc::Configuration::InstanceConfiguration.validate_value(value)
     if default_value.is_a?(Array)
       return value.to_csv.strip
     else # boolean, String, Fixnum / Float

data/app/controllers/pages_controller.rb

@@ -15,7 +15,17 @@
 # limitations under the License.
 
 class PagesController < ApplicationController
+  def components
+    #authorize! :read, :components
+    @concepts_uri = concepts_path(:format => :json)
+    @concept_uri = concept_path(:id => "{id}")
+  end
+
   def help
     authorize! :read, :help
   end
+
+  def version
+    authorize! :read, :version
+  end
 end

data/app/controllers/search_results_controller.rb

@@ -113,13 +113,13 @@ class SearchResultsController < ApplicationController
 
       if klass.forces_multi_query? || (klass.supports_multi_query? && query_size > 1)
         @multi_query = true
-        @results = klass.multi_query(params.merge({ languages: languages }))
+        @results = klass.multi_query(params.merge({ languages: languages.flatten }))
         # TODO: Add a worst case limit here; e.g. when on page 2 (per_page == 50)
         # each sub-query has to return 100 objects at most.
         @klass = klass
       else
         @multi_query = false
-        @results = klass.single_query(params.merge({ languages: languages }))
+        @results = klass.single_query(params.merge({ languages: languages.flatten }))
       end
 
       if @multi_query

data/app/controllers/triplestore_sync_controller.rb

@@ -14,10 +14,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'iqvoc/rdf_sync'
-
 class TriplestoreSyncController < ApplicationController
-  include Iqvoc::RDFSync::Helper
+  include RDFSyncService::Helper
 
   def index
     authorize! :use, :dashboard
@@ -42,7 +40,7 @@ class TriplestoreSyncController < ApplicationController
     end
 
     # per-class pagination
-    @candidates = Iqvoc::RDFSync.candidates.map do |records|
+    @candidates = RDFSyncService.candidates.map do |records|
       records.page(params[:page])
     end
   end

data/app/helpers/application_helper.rb

@@ -56,7 +56,7 @@ module ApplicationHelper
 
   def page_header(args = {})
     if title = args[:title]
-      content_for(:title, title)
+      content_for(:title, strip_tags(title))
     end
 
     content_for :page_header do

data/app/helpers/widget_helper.rb

@@ -5,13 +5,13 @@ module WidgetHelper
 
   def widget_values_ranked(concept, relation_class)
     concepts_with_ranks = concept.concept_relations_by_id_and_rank(relation_class.name.to_relation_name)
-    concepts_with_ranks.map { |concept, rank| "#{concept.origin}:#{rank}" }.join(Iqvoc::InlineDataHelper::JOINER)
+    concepts_with_ranks.map { |concept, rank| "#{concept.origin}:#{rank}" }.join(InlineDataHelper::JOINER)
   end
 
   def widget_entities(concept, relation_class)
     origins = concept.
       concept_relations_by_id(relation_class.name.to_relation_name).
-      split(Iqvoc::InlineDataHelper::SPLITTER)
+      split(InlineDataHelper::SPLITTER)
 
     Iqvoc::Concept.base_class.
       editor_selectable.
@@ -23,7 +23,7 @@ module WidgetHelper
   def widget_entities_ranked(concept, relation_class)
     origins = concept.
       concept_relations_by_id(relation_class.name.to_relation_name).
-      split(Iqvoc::InlineDataHelper::SPLITTER)
+      split(InlineDataHelper::SPLITTER)
 
     allowed_concepts = Iqvoc::Concept.base_class.
       editor_selectable.

data/app/jobs/export_job.rb

@@ -1,10 +1,8 @@
-require 'iqvoc/skos_exporter'
-
 class ExportJob < Struct.new(:export, :filename, :type, :base_uri)
   def perform
     strio = StringIO.new
 
-    exporter = Iqvoc::SkosExporter.new(filename, type, base_uri, Logger.new(strio))
+    exporter = SkosExporter.new(filename, type, base_uri, Logger.new(strio))
     exporter.run
     @messages = strio.string
   end

data/app/jobs/import_job.rb

@@ -1,10 +1,8 @@
-require 'iqvoc/skos_importer'
-
 class ImportJob < Struct.new(:import, :filename, :user, :namespace, :publish)
   def perform
     strio = StringIO.new
 
-    importer = Iqvoc::SkosImporter.new(filename, namespace, Logger.new(strio), publish)
+    importer = SkosImporter.new(filename, namespace, Logger.new(strio), publish)
     importer.run
     @messages = strio.string
   end

data/app/models/ability.rb

@@ -0,0 +1,59 @@
+class Ability
+  include CanCan::Ability
+
+  @@if_published = lambda { |o| o.published? }
+
+  def initialize(user = nil)
+    can :read, Iqvoc::Concept.root_class.instance
+    can :read, [::Concept::Base, ::Collection::Base, ::Label::Base], &@@if_published
+
+    # static pages
+    can :read, :help
+    can :read, :version
+
+    if user # Every logged in user ...
+      can :use, :dashboard
+      can :destroy, UserSession
+
+      if user.owns_role?(:editor) || user.owns_role?(:publisher) || user.owns_role?(:administrator) # Editors and above ...
+        can :read, [::Concept::Base, ::Collection::Base, ::Label::Base]
+        can :create, [::Concept::Base, ::Collection::Base, ::Label::Base]
+        can [:update, :destroy, :unlock], [::Concept::Base, ::Collection::Base, ::Label::Base], locked_by: user.id, published_at: nil
+        can :lock, [::Concept::Base, ::Collection::Base, ::Label::Base], locked_by: nil, published_at: nil
+        can [:check_consistency, :send_to_review], [::Concept::Base, ::Collection::Base, ::Label::Base], published_at: nil
+        can :branch, [::Concept::Base, ::Collection::Base, ::Label::Base], &@@if_published
+      end
+
+      if user.owns_role?(:match_editor)
+        can :read, ::Concept::Base
+        can :create, ::Concept::Base
+        can [:update, :lock], ::Concept::Base, locked_by: user.id, published_at: nil
+        can :lock, ::Concept::Base, locked_by: nil, published_at: nil
+        can :branch, ::Concept::Base, &@@if_published
+      end
+
+      if user.owns_role?(:publisher) || user.owns_role?(:administrator) # Publishers and above ...
+        can :merge, [::Concept::Base, ::Collection::Base, ::Label::Base], published_at: nil
+      end
+
+      if user.owns_role?(:administrator)
+        can [:update, :destroy, :unlock], [::Concept::Base, ::Label::Base], published_at: nil # Mustn't be locked by myself
+
+        can :manage, User
+        can :manage, Iqvoc.config
+
+        can :full_export, ::Concept::Base
+        can :import, ::Concept::Base
+        can :export, ::Concept::Base
+
+        can :update, Iqvoc::Concept.root_class.instance
+
+        can :use, :administration
+
+        can :reset, :thesaurus
+      end
+    else # no user
+      can :create, UserSession
+    end
+  end
+end

data/app/models/abstract_user.rb

@@ -46,6 +46,6 @@ class AbstractUser < ActiveRecord::Base
   end
 
   def ability
-    @ability ||= Iqvoc::Ability.new(self)
+    @ability ||= Ability.new(self)
   end
 end

data/app/models/collection/base.rb

@@ -34,7 +34,16 @@ class Collection::Base < Concept::Base
 
   include_to_deep_cloning(:members, :collection_members)
 
-  after_save :regenerate_concept_members, :regenerate_collection_members
+  # ********** Hooks
+
+  after_initialize do |collection|
+    if collection.origin.blank?
+      collection.origin = Origin.new.to_s
+    end
+  end
+
+  after_save :regenerate_concept_members,
+             :regenerate_collection_members
 
   validate :circular_subcollections
 
@@ -90,7 +99,7 @@ class Collection::Base < Concept::Base
 
   def inline_member_concept_origins=(origins)
     @member_concept_origins = origins.to_s.
-        split(Iqvoc::InlineDataHelper::SPLITTER).map(&:strip)
+        split(InlineDataHelper::SPLITTER).map(&:strip)
   end
 
   def inline_member_concept_origins
@@ -107,7 +116,7 @@ class Collection::Base < Concept::Base
 
   def inline_member_collection_origins=(origins)
     @member_collection_origins = origins.to_s.
-        split(Iqvoc::InlineDataHelper::SPLITTER).map(&:strip)
+        split(InlineDataHelper::SPLITTER).map(&:strip)
   end
 
   def inline_member_collection_origins

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

@@ -24,7 +24,7 @@ class Collection::Member::SKOS::Base < Collection::Member::Base
 
     member_instance = rdf_subject.members.detect{ |rel| rel.target == rdf_object }
     if member_instance.nil?
-      predicate_class = Iqvoc::RDFAPI::PREDICATE_DICTIONARY[rdf_predicate] || self
+      predicate_class = RDFAPI::PREDICATE_DICTIONARY[rdf_predicate] || self
       member_instance = predicate_class.new(target: rdf_object)
       rdf_subject.members << member_instance
     end

data/app/models/concept/base.rb

@@ -32,9 +32,16 @@ class Concept::Base < ActiveRecord::Base
   include Versioning
   include Concept::Validations
   include FirstLevelObjectValidations
+  include FirstLevelObjectScopes
 
   # ********** Hooks
 
+  after_initialize do |concept|
+    if concept.origin.blank?
+      concept.origin = Origin.new.to_s
+    end
+  end
+
   before_validation do |concept|
     # Handle save or destruction of inline relations (relations or labelings)
     # for use with widgets etc.
@@ -50,7 +57,7 @@ class Concept::Base < ActiveRecord::Base
         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|
+          InlineDataHelper.parse_inline_values(inline_values).each do |value|
             value.squish!
             unless value.blank?
               self.send(relation_name).build(target: labeling_class.label_class.new(value: value, language: lang))
@@ -72,7 +79,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(InlineDataHelper::SPLITTER).map(&:squish)
 
       # Extract embedded ranks (if any) from origin strings (e.g. "origin1:100")
       # => { 'origin1' => nil, 'origin2' => 90 }
@@ -184,7 +191,7 @@ class Concept::Base < ActiveRecord::Base
     unless Iqvoc::Concept.labeling_classes.keys.detect { |klass| labeling_class_name.constantize < klass }
       # When a Label has only one labeling (the "no skosxl" case) we'll have to
       # clone the label too.
-      if labeling_class_name.constantize.reflections[:target].options[:dependent] == :destroy
+      if labeling_class_name.constantize.reflections['target'].options[:dependent] == :destroy
         include_to_deep_cloning(labeling_class_name.to_relation_name => :target)
       else
         include_to_deep_cloning(labeling_class_name.to_relation_name)
@@ -199,13 +206,13 @@ class Concept::Base < ActiveRecord::Base
       class_name: match_class_name,
       foreign_key: 'concept_id'
 
-    # Serialized setters and getters (\r\n or , separated) -- TODO: use Iqvoc::InlineDataHelper?
+    # Serialized setters and getters (\r\n or , separated) -- TODO: use InlineDataHelper?
     define_method("inline_#{match_class_name.to_relation_name}".to_sym) do
-      self.send(match_class_name.to_relation_name).map(&:value).join(Iqvoc::InlineDataHelper::JOINER)
+      self.send(match_class_name.to_relation_name).map(&:value).join(InlineDataHelper::JOINER)
     end
 
     define_method("inline_#{match_class_name.to_relation_name}=".to_sym) do |value|
-      urls = value.split(Iqvoc::InlineDataHelper::SPLITTER).map(&:strip).reject(&:blank?)
+      urls = value.split(InlineDataHelper::SPLITTER).map(&:strip).reject(&:blank?)
       self.send(match_class_name.to_relation_name).each do |match|
         if (urls.include?(match.value))
           urls.delete(match.value) # We're done with that one
@@ -319,7 +326,7 @@ class Concept::Base < ActiveRecord::Base
   def labelings_by_text(relation_name, language)
     (@labelings_by_text && @labelings_by_text[relation_name] &&
         @labelings_by_text[relation_name][language]) ||
-        Iqvoc::InlineDataHelper.generate_inline_values(self.send(relation_name).
+        InlineDataHelper.generate_inline_values(self.send(relation_name).
             by_label_language(language).map { |l| l.target.value })
   end
 
@@ -330,7 +337,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(InlineDataHelper::JOINER)
   end
 
   def concept_relations_by_id_and_rank(relation_name)

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

@@ -124,6 +124,6 @@ class Concept::Relation::Base < ActiveRecord::Base
   end
 
   def self.rankable?
-    self.class.included_modules.include?(Iqvoc::Rankable)
+    self.class.included_modules.include?(Rankable)
   end
 end

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

@@ -21,7 +21,7 @@ class Concept::Relation::SKOS::Base < Concept::Relation::Base
     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
 
-    relation_class = Iqvoc::RDFAPI::PREDICATE_DICTIONARY[rdf_predicate] || self
+    relation_class = RDFAPI::PREDICATE_DICTIONARY[rdf_predicate] || self
 
     relation_instance = rdf_subject.send(self.name.to_relation_name).select{ |rel| rel.target == rdf_object }
     if relation_instance.empty?

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

@@ -61,7 +61,7 @@ class Concept::SKOS::Scheme < Concept::Base
 
   def inline_top_concept_origins=(origins)
     @inline_top_concept_origins = origins.to_s.
-      split(Iqvoc::InlineDataHelper::SPLITTER).map(&:strip)
+      split(InlineDataHelper::SPLITTER).map(&:strip)
   end
 
   def inline_top_concept_origins

data/app/models/concept/validations.rb

@@ -16,7 +16,7 @@ module Concept
     # top term and broader relations are mutually exclusive
     def exclusive_top_term
       if validatable_for_publishing?
-        if top_term && broader_relations.any?
+        if top_term? && broader_relations.any?
           errors.add :base, I18n.t('txt.models.concept.top_term_exclusive_error')
         end
       end

data/app/models/concerns/deep_cloning.rb

@@ -0,0 +1,92 @@
+# encoding: UTF-8
+
+# Copyright 2011-2013 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.
+
+require 'active_support/concern'
+
+module DeepCloning
+  extend ActiveSupport::Concern
+
+  included do #:nodoc:
+    alias_method_chain :dup, :deep_cloning
+  end
+
+  # clones an ActiveRecord model.
+  # if passed the :include option, it will deep clone the given associations
+  # if passed the :except option, it won't clone the given attributes
+  #
+  # === Usage:
+  #
+  # ==== Cloning a model without an attribute
+  # pirate.clone except: :name
+  #
+  # ==== Cloning a model without multiple attributes
+  # pirate.clone except: [:name, :nick_name]
+  # ==== Cloning one single association
+  # pirate.clone include: :mateys
+  #
+  # ==== Cloning multiple associations
+  # pirate.clone include: [:mateys, :treasures]
+  #
+  # ==== Cloning really deep
+  # pirate.clone include: {treasures: :gold_pieces}
+  #
+  # ==== Cloning really deep with multiple associations
+  # pirate.clone include: [:mateys, {treasures: :gold_pieces}]
+  #
+  # ==== Cloning multiple associations - but only the join table entries without cloning the associated objects themselves
+  # pirate.clone include_association: [:matey_ids, :treasure_ids]
+  #
+  def dup_with_deep_cloning(options = {})
+    kopy = dup_without_deep_cloning
+
+    if options[:except]
+      Array(options[:except]).each do |attribute|
+        kopy.write_attribute(attribute, attributes_from_column_definition[attribute.to_s])
+      end
+    end
+
+    if options[:include_association]
+      Array(options[:include_association]).each do |association_attribute|
+        kopy.send("#{association_attribute}=", self.send("#{association_attribute}"))
+      end
+    end
+
+    if options[:include]
+      Array(options[:include]).each do |association, deep_associations|
+        if (association.kind_of? Hash)
+          deep_associations = association[association.keys.first]
+          association = association.keys.first
+        end
+        opts = deep_associations.blank? ? {} : { include: deep_associations }
+        association_reflection = self.class.reflect_on_association(association)
+        cloned_object = case association_reflection.macro
+        when :belongs_to, :has_one
+          self.send(association) && self.send(association).dup(opts)
+        when :has_many, :has_and_belongs_to_many
+          fk = association_reflection.options[:foreign_key]# || self.class.to_s.underscore
+          self.send(association).collect do |obj|
+            cloned_obj = obj.dup(opts)
+            cloned_obj.send("#{fk}=", kopy.id) unless fk.blank?
+            cloned_obj
+          end
+        end
+        kopy.send("#{association}=", cloned_object)
+      end
+    end
+
+    return kopy
+  end
+end