iqvoc 4.7.0 → 4.8.0

data/lib/iqvoc/navigation.rb

@@ -1,61 +0,0 @@
-# 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.
-
-##
-# Provides a basic API wrapping low-level iQvoc config operations
-# on Iqvoc.navigation_items
-
-module Iqvoc
-  module Navigation
-    def self.items
-      Iqvoc.navigation_items
-    end
-
-    def self.add(item, position = nil)
-      if position
-        items.insert(position, item)
-      else
-        items << item
-      end
-    end
-
-    def self.add_grouped(item, position = nil)
-      index = setup_extension_group(position)
-      items[index][:items] << item
-    end
-
-    private
-    # Setup an empty navigation group for extensions
-    # Returns index for the new (or existing) group, so add_grouped
-    # can use the index to insert it's item under the group
-    def self.setup_extension_group(position)
-      group = {
-        text: proc { t('txt.views.navigation.extensions') },
-        items: []
-      }
-
-      if position && !items[position][:items]
-        items.insert(position, group)
-      elsif position && items[position][:items]
-        return position
-      else
-        items << group
-      end
-
-      items.index(group)
-    end
-  end
-end

data/lib/iqvoc/origin.rb

@@ -1,111 +0,0 @@
-# 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.
-
-# Provides utilities to replace special chars etc in
-# texts to generate a valid turtle compatible id (an url slug):
-# Iqvoc::Origin.new("fübar").to_s # => "fuebar"
-#
-# Note that .to_s respects eventually previously executed method chains
-# Just calling "to_s" runs all registered filters.
-# Prepending "to_s" with a specific filter method only runs the given filter:
-# Iqvoc::Origin.new("fübar").replace_umlauts.to_s # => "fuebar"
-#
-# Adding your own filter classes is easy:
-# class FoobarStripper < Iqvoc::Origin::Filters::GenericFilter
-#   def call(obj, str)
-#     str = str.gsub("foobar", "")
-#     run(obj, str)
-#   end
-# end
-# Iqvoc::Origin::Filters.register(:strip_foobars, FoobarStripper)
-#
-module Iqvoc
-  class Origin
-    module Filters
-      class GenericFilter
-        def call(obj, str)
-          # do what has to be done with str
-          # afterwards: make sure to pass "obj" and your modified "str" to "run()"
-          run(obj, str)
-        end
-
-        def run(obj, str)
-          obj.tap do |obj|
-            obj.value = str
-          end
-        end
-      end
-
-      class UriConformanceFilter < GenericFilter
-        def call(obj, str)
-          str = str.parameterize # basic url conformance
-
-          # prefix with '_' if origin starts with digit
-          str = str.gsub(/^[0-9].*$/) do |match|
-            "_#{match}"
-          end
-          run(obj, str)
-        end
-      end
-
-      @filters = {}
-      @filters[:uri_conformance_filter] = UriConformanceFilter
-
-      def self.register(name, klass)
-        @filters[name.to_sym] = klass
-      end
-
-      def self.registered
-        @filters
-      end
-    end
-
-    attr_accessor :initial_value, :value, :filters
-
-    def initialize(value)
-      self.initial_value = value.to_s
-      self.value = initial_value
-    end
-
-    def touched?
-      value != initial_value
-    end
-
-    def run_filters!
-      Filters.registered.each do |key, filter_class|
-        filter_class.new.call(self, value)
-      end
-    end
-
-    def method_missing(meth, *args)
-      if Filters.registered.keys.include?(meth.to_sym)
-        Filters.registered[meth.to_sym].new.call(self, value)
-      else
-        super
-      end
-    end
-
-    def to_s
-      return value if touched?
-      run_filters!
-      value
-    end
-
-    def inspect
-      '#<Iqvoc::Origin:0x%08x>' % object_id
-    end
-  end
-end

data/lib/iqvoc/rankable.rb

@@ -1,33 +0,0 @@
-require 'active_support/concern'
-
-module Iqvoc
-  module Rankable
-    extend ActiveSupport::Concern
-
-    def build_rdf(document, subject, suppress_extra_labels = false)
-      super
-      if self.class.rankable?
-        predicate = "ranked#{rdf_predicate.titleize}"
-
-        subject.Schema.build_predicate(predicate) do |blank_node|
-          blank_node.Schema.relationWeight(rank)
-          blank_node.Schema.relationTarget(IqRdf.build_uri(target.origin))
-        end
-      end
-    end
-
-    module ClassMethods
-      def rankable?
-        true
-      end
-
-      def partial_name(obj)
-        'partials/concept/relation/ranked'
-      end
-
-      def edit_partial_name(obj)
-        'partials/concept/relation/edit_ranked'
-      end
-    end
-  end
-end

data/lib/iqvoc/rdfapi.rb

@@ -1,60 +0,0 @@
-# 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.
-
-module Iqvoc
-  module RDFAPI
-    FIRST_LEVEL_OBJECT_CLASSES  = [Iqvoc::Concept.base_class, Iqvoc::Collection.base_class]
-    SECOND_LEVEL_OBJECT_CLASSES = Iqvoc::Concept.labeling_classes.keys +
-                                  Iqvoc::Concept.note_classes +
-                                  Iqvoc::Concept.relation_classes +
-                                  Iqvoc::Concept.match_classes +
-                                  Iqvoc::Concept.notation_classes +
-                                  Iqvoc::Concept.additional_association_classes.keys +
-                                  [Iqvoc::Collection.member_class]
-
-    OBJECT_DICTIONARY = FIRST_LEVEL_OBJECT_CLASSES.inject({}) do |hash, klass|
-      hash["#{klass.rdf_namespace}:#{klass.rdf_class}"] = klass
-      hash
-    end
-
-    PREDICATE_DICTIONARY = SECOND_LEVEL_OBJECT_CLASSES.inject({}) do |hash, klass|
-      hash["#{klass.rdf_namespace}:#{klass.rdf_predicate}"] = klass
-      hash
-    end
-
-    URI_REGEXP = /^https?:\/\/[^\s]+$/
-    LITERAL_REGEXP = /^"(.+)"(@(.+))?$/
-
-    def self.devour(rdf_subject, rdf_predicate, rdf_object)
-      case rdf_predicate
-      when 'a', 'rdf:type'
-        case rdf_object
-        when String
-          target = OBJECT_DICTIONARY[rdf_object] || rdf_object.constantize
-        else
-          target = rdf_object
-        end
-        target.find_or_initialize_by(origin: rdf_subject)
-      when String
-        # dictionary lookup
-        target = PREDICATE_DICTIONARY[rdf_predicate] || rdf_predicate.constantize
-        target.build_from_rdf(rdf_subject, target, rdf_object)
-      else # is a class
-        rdf_predicate.build_from_rdf(rdf_subject, rdf_predicate, rdf_object)
-      end
-    end
-  end
-end

data/lib/iqvoc/skos_exporter.rb

@@ -1,153 +0,0 @@
-require 'iq_rdf'
-require 'uri'
-require 'fileutils'
-
-module Iqvoc
-  class SkosExporter
-    include RdfHelper # necessary to use render_concept helper
-    include RdfNamespacesHelper
-    include Rails.application.routes.url_helpers
-
-    def initialize(file_path, type, default_namespace_url, logger = Rails.logger)
-      default_url_options[:port] = URI.parse(default_namespace_url).port
-      default_url_options[:host] = URI.parse(default_namespace_url).to_s.gsub(/\/$/, '')
-
-      @file_path = file_path
-      @type = type
-      @logger = logger
-      @document = IqRdf::Document.new
-
-      unless ['ttl', 'nt', 'xml'].include? @type
-        raise "Iqvoc::SkosExporter: Unknown rdf serialization. Parameter 'type' should be 'ttl' (Turtle), 'nt' (N-Triples) or 'xml' (RDF-XML)."
-      end
-
-      unless @file_path.is_a?(String)
-        raise "Iqvoc::SkosExporter#export: Parameter 'file' should be a String."
-      end
-    end
-
-    def run
-      export
-    end
-
-    private
-
-    def export
-      ActiveSupport.run_load_hooks(:rdf_export_before, self)
-
-      start = Time.now
-      @logger.info 'Starting export...'
-      @logger.info "file_path = #{@file_path}"
-      @logger.info "type = #{@type}"
-
-      # add export data
-      add_namespaces(@document)
-      add_collections(@document)
-      add_concepts(@document)
-
-      ActiveSupport.run_load_hooks(:rdf_export_before_save, self)
-
-      # saving export to disk
-      save_file(@file_path, @type, @document)
-
-      done = Time.now
-      @logger.info "Export Job finished in #{(done - start).to_i} seconds."
-
-      ActiveSupport.run_load_hooks(:rdf_export_after, self)
-    end
-
-    def add_namespaces(document)
-      @logger.info 'Exporting namespaces...'
-
-      RdfNamespacesHelper.instance_methods.each do |meth|
-        namespaces = send(meth)
-        document.namespaces(namespaces) if namespaces.is_a?(Hash)
-      end
-
-      @logger.info 'Finished exporting namespaces.'
-    end
-
-    def add_collections(document)
-      @logger.info 'Exporting collections...'
-
-      offset = 0
-      while true
-        collections = Iqvoc::Collection.base_class.published.order('id').limit(100).offset(offset)
-        limit = collections.size < 100 ? collections.size : 100
-        break if collections.size == 0
-
-        # Todo: Preloading???
-        collections.each do |collection|
-          render_collection(document, collection)
-        end
-
-        @logger.info "Collections #{offset+1}-#{offset+limit} exported."
-        offset += collections.size # Size is important!
-      end
-
-      @logger.info "Finished exporting collections (#{offset} collections exported)."
-    end
-
-    def add_concepts(document)
-      @logger.info 'Exporting concepts...'
-
-      offset = 0
-      while true
-        concepts = Iqvoc::Concept.base_class.published.order('id').limit(100).offset(offset)
-        limit = concepts.size < 100 ? concepts.size : 100
-        break if concepts.size == 0
-
-        # When in single query mode, AR handles ALL includes to be loaded by that
-        # one query. We don't want that! So let's do it manually :-)
-        ActiveRecord::Associations::Preloader.new.preload(concepts,
-          Iqvoc::Concept.base_class.default_includes + [
-              :matches,
-              :collection_members,
-              :notations,
-              { relations: :target, labelings: :target, notes: :annotations }
-          ])
-
-        concepts.each do |concept|
-          render_concept(document, concept, true)
-        end
-
-        @logger.info "Concepts #{offset+1}-#{offset+limit} exported."
-        offset += concepts.size # Size is important!
-      end
-
-      @logger.info "Finished exporting concepts (#{offset} concepts exported)."
-    end
-
-    def save_file(file_path, type, content)
-      begin
-        @logger.info "Saving export to '#{@file_path}'"
-        create_directory(@file_path)
-        file = File.open(@file_path, 'w')
-        content = serialize_rdf(content, type)
-        file.write(content)
-      rescue IOError => e
-        # some error occur
-        # e.g not writable
-      ensure
-        file.close unless file == nil
-      end
-    end
-
-    def create_directory(file_path)
-      dirname = File.dirname(file_path)
-      unless File.directory?(dirname)
-        FileUtils.mkdir_p(dirname)
-      end
-    end
-
-    def serialize_rdf(document, type)
-      if type == 'xml'
-        document.to_xml
-      elsif type == 'ttl'
-        document.to_turtle
-      else
-        document.to_ntriples
-      end
-    end
-  end
-end

data/lib/iqvoc/skos_importer.rb

@@ -1,337 +0,0 @@
-require 'iqvoc/rdfapi'
-
-module Iqvoc
-  class SkosImporter
-    class_attribute :first_level_object_classes, :second_level_object_classes
-    self.first_level_object_classes = [
-      Iqvoc::Concept.base_class,
-      Iqvoc::Collection.base_class
-    ]
-    self.second_level_object_classes = Iqvoc::Concept.labeling_classes.keys +
-      Iqvoc::Concept.note_classes +
-      Iqvoc::Concept.relation_classes +
-      Iqvoc::Concept.match_classes +
-      Iqvoc::Concept.notation_classes +
-      Iqvoc::Concept.additional_association_classes.keys +
-      [Iqvoc::Concept.root_class] +
-      [Iqvoc::Collection.member_class]
-
-    def self.prepend_first_level_object_classes(args)
-      self.first_level_object_classes.unshift(*args)
-    end
-
-    def initialize(object, default_namespace_url, logger = Rails.logger, publish = true, verbose = false)
-      @file = case object
-                when File
-                  File.open(object)
-                when Array
-                  object
-                else
-                  open(object)
-              end
-
-      @default_namespace_url = default_namespace_url
-      @publish = publish
-      @verbose = verbose
-      @logger = logger
-
-      unless @file.is_a?(File) || @file.is_a?(Array)
-        raise "Iqvoc::SkosImporter#import: Parameter 'file' should be a File or an Array."
-      end
-
-      # Some general Namespaces to support in any case
-      @prefixes = {
-        'http://www.w3.org/2004/02/skos/core#' => 'skos:',
-        'http://www.w3.org/2008/05/skos#' => 'skos:',
-        'http://www.w3.org/1999/02/22-rdf-syntax-ns#' => 'rdf:',
-        default_namespace_url => ':'
-      }
-      # Add the namespaces specified in the Iqvoc config
-      Iqvoc.rdf_namespaces.each do |pref, uri|
-        @prefixes[uri] = "#{pref.to_s}:"
-      end
-
-      @seen_first_level_objects = {} # Concept cache (don't load any concept twice from db)
-
-      # Assign the default concept scheme singleton instance as a seen first level object upfront
-      # in order to handle a missing scheme definition in ntriple data
-      @seen_first_level_objects[Iqvoc::Concept.root_class.instance.origin] = Iqvoc::Concept.root_class
-
-      @new_subjects = {} # Concepts, collections, labels etc. to be published later
-
-      # Triples the importer doesn't understand immediately. Example:
-      #
-      #     :a skos:prefLabel "foo". # => What is :a? Remember this and try again later
-      #     ....
-      #     :a rdf:type skos:Concept # => Now I know :a, good I remembered it's prefLabel...
-      @unknown_second_level_triples = Set.new
-
-      # Hash of arrays of arrays: { "_:n123" => [["pred1", "obj1"], ["pred2", "obj2"]] }
-      @blank_nodes = {}
-
-      @existing_origins = {} # To prevent the creation of first level objects we already have
-      first_level_object_classes.each do |klass|
-        klass.select('origin').load.each do |thing|
-          @existing_origins[thing.origin] = klass
-        end
-      end
-    end
-
-    def run
-      print_known_namespaces
-      print_known_import_classes
-      import @file
-    end
-
-    private
-
-    def import(file)
-      ActiveSupport.run_load_hooks(:skos_importer_before_import, self)
-
-      start = Time.now
-
-      @logger.info "default namespace: '#{@default_namespace_url}'"
-      @logger.info "publish: '#{@publish}'"
-
-      first_level_types = {} # type identifier ("namespace:SomeClass") to Iqvoc class assignment hash
-      first_level_object_classes.each do |klass|
-        first_level_types["#{klass.rdf_namespace}:#{klass.rdf_class}"] = klass
-      end
-      second_level_types = {}
-      second_level_object_classes.each do |klass|
-        second_level_types["#{klass.rdf_namespace}:#{klass.rdf_predicate}"] = klass
-      end
-
-      @logger.info 'Iqvoc::SkosImporter: Importing triples...'
-      file.each_with_index do |line, index|
-        extracted_triple = *extract_triple(line)
-
-        if @verbose && has_unknown_namespaces?(extracted_triple)
-          @logger.warn "Iqvoc::SkosImporter: Unknown namespaces. Skipping #{extracted_triple.join(' ')}"
-        end
-
-        identify_blank_nodes(*extracted_triple) ||
-          import_first_level_objects(first_level_types, *extracted_triple) ||
-          import_second_level_objects(second_level_types, false, line)
-      end
-
-      # treeify blank nodes hash
-      @blank_nodes.each do |origin, bnode_struct|
-        tranform_blank_node(origin, bnode_struct)
-      end
-
-      @logger.info "Computing 'forward' defined triples..."
-      @unknown_second_level_triples.each do |line|
-        import_second_level_objects(second_level_types, true, line)
-      end
-
-      first_import_step_done = Time.now
-      @logger.info "Basic import done (took #{(first_import_step_done - start).to_i} seconds)."
-
-      published = publish
-
-      done = Time.now
-      @logger.info "Publishing of #{published} subjects done (took #{(done - first_import_step_done).to_i} seconds). #{@new_subjects.count - published} are in draft state."
-      @logger.info "Imported #{published} published and #{@new_subjects.count - published} draft subjects in #{(done - start).to_i} seconds."
-      @logger.info "First step took #{(first_import_step_done - start).to_i} seconds, publishing took #{(done - first_import_step_done).to_i} seconds."
-
-      ActiveSupport.run_load_hooks(:skos_importer_after_import, self)
-    end
-
-    def publish
-      published = 0
-      # Respect order of first level classes configured in FIRST_LEVEL_OBJECTS
-      # Example: XL labels have to be published before referencing concepts
-      sorted_new_subjects = @new_subjects.sort_by do |origin, klass|
-        first_level_object_classes.index(klass)
-      end
-
-      if @publish
-        @logger.info "Publishing #{@new_subjects.count} new subjects..."
-
-        sorted_new_subjects.each do |origin, klass|
-          subject = klass.find_by(origin: origin)
-          if subject.publishable?
-            subject.publish!
-            published += 1
-          else
-            @logger.warn "WARNING: Publishing failed! Subject ('#{subject.origin}') invalid: #{subject.errors.to_hash.inspect}"
-          end
-        end
-      end
-      published
-    end
-
-    def identify_blank_nodes(subject, predicate, object)
-      if blank_node?(subject)
-        @blank_nodes[subject] ||= []
-        @blank_nodes[subject] << [predicate, object]
-        true
-      else
-        false
-      end
-    end
-
-    def import_first_level_objects(types, subject, predicate, object)
-      if (predicate == 'rdf:type' && types[object] && subject =~ /^:(.+)$/)
-        # We've found a subject definition with a class we know and which is in our responsibility (":")
-        origin = $1
-
-        if (@existing_origins[origin])
-          if (types[object] == @existing_origins[origin])
-            @logger.info "Iqvoc::SkosImporter: Subject with origin '#{origin}' already exists. Skipping duplicate creation (should be no problem)."
-          else
-            @logger.warn "Iqvoc::SkosImporter: Subject with origin '#{origin} already exists but has another class (#{@existing_origins[origin]}) then the one I wanted to create (#{types[object]}). You seem to have a problem with your configuration!"
-          end
-        else
-          @logger.info "Iqvoc::SkosImporter: Creating Subject: #{subject} #{predicate} #{object}" if @verbose
-          # FIXME
-
-          types[object].create do |klass|
-            klass.origin = origin
-          end
-          @seen_first_level_objects[origin] = types[object]
-          @new_subjects[origin] = types[object]
-        end
-        true
-      else
-        false
-      end
-    end
-
-    def import_second_level_objects(types, final, line)
-      subject, predicate, object = *extract_triple(line)
-
-      return unless (subject =~ /^:(.*)$/ && types[predicate]) # We're not responsible for this
-
-      # Load the subject and replace the string by the respective data object
-      subject_origin = $1
-      subject = load_first_level_object(subject_origin)
-      unless subject
-        if final
-          @logger.warn "Iqvoc::SkosImporter: Couldn't find Subject with origin '#{subject_origin}. Skipping entry '#{subject} #{predicate} #{object}.'"
-        else
-          @unknown_second_level_triples << line
-        end
-        return false
-      end
-
-      # Load the data object for the object string if this is representing a thing in our domain
-      if (object =~ /^:(.*)$/ && types[predicate])
-        object_origin = $1
-        object = load_first_level_object(object_origin)
-        unless object
-          if final
-            @logger.warn "Iqvoc::SkosImporter: Couldn't find Object with origin '#{object_origin}'. Skipping entry ':#{subject_origin} #{predicate} #{object_origin}.'"
-          else
-            @unknown_second_level_triples << line
-          end
-          return false
-        end
-      end
-
-      # If not in final mode every :my_concept :bla _:blank_node. triple should
-      # be saved for final mode. Why? Example:
-      #
-      #    :a iqvoc:changeNote _:b01 # => I do not know know anything about the blank node now
-      #    _:b01 dc:author "DHH"...
-      #
-      if blank_node?(object)
-        if final
-          object = @blank_nodes[object]
-        else
-          @unknown_second_level_triples << line
-          return false
-        end
-      end
-      begin
-        types[predicate].build_from_rdf(subject, predicate, object)
-      rescue InvalidStringLiteralError => e
-        @logger.warn e.message
-      end
-    end
-
-    def load_first_level_object(origin)
-      unless @seen_first_level_objects[origin]
-        klass = @existing_origins[origin]
-        if klass
-          @seen_first_level_objects[origin] = klass
-        end
-      end
-
-      # FIXME: bang
-      # FIXME: return something?
-      if klass = @seen_first_level_objects[origin]
-        klass.find_by!(origin: origin)
-      end
-    end
-
-    def blank_node?(str)
-      str.dup.to_s =~ /^_:.+/
-    end
-
-    def extract_triple(line)
-      raise "'#{line}' doesn't look like valid ntriples data." unless line =~ /^(.*)\.\s*$/
-      line = $1.squish
-
-      triple = line.split(' ', 3) # The first one are uris the last can be a literal too
-
-      triple.each do |e| # Do some fun with the uris and literals
-        @prefixes.keys.each do |uri_prefix| # Use prefixes instead of full uris
-          e.gsub! /^<#{uri_prefix}([^>]*)>/ do |matches|
-            @prefixes[uri_prefix] + $1.gsub('.', '_')
-          end
-        end
-        e.squish!
-        e.gsub!(/^:(.*)$/) do
-          ":#{Iqvoc::Origin.new($1)}" # Force correct origins in the default namespace
-        end
-      end
-      triple
-    end
-
-    def has_unknown_namespaces?(triple)
-      triple.each do |obj|
-        return true if obj =~ /^<.*>$/
-        break
-      end
-      false
-    end
-
-    # if blank node contains another blank node,
-    # move child blank node to his parent
-    def tranform_blank_node(origin, bnode_struct)
-      bnode_struct.each_index do |i|
-        bnode_origin = bnode_struct[i][1] # only origin could contain another blank node
-        if blank_node?(bnode_origin)
-          bnode_child_struct = @blank_nodes[bnode_origin]
-          bnode_struct[i][1] = bnode_child_struct # move to parent node
-          tranform_blank_node(bnode_origin, bnode_child_struct)
-
-          @blank_nodes.delete(bnode_origin) # remove old blank node
-        end
-      end
-    end
-
-    def print_known_namespaces
-      @logger.info "Known namespaces:"
-      @prefixes.each_with_index do |(uri, pref), i|
-        @logger.info "\t #{i+1}: #{pref} => #{uri}"
-      end
-    end
-
-    def print_known_import_classes
-      @logger.info "Known first level classes:"
-      first_level_object_classes.each_with_index do |floc, i|
-        @logger.info "\t #{i+1}: #{floc.rdf_namespace}:#{floc.rdf_class} => #{floc.to_s}"
-      end
-
-      @logger.info "Known second level classes:"
-      second_level_object_classes.each_with_index do |sloc, i|
-        @logger.info "\t #{i+1}: #{sloc.rdf_namespace}:#{sloc.rdf_predicate} => #{sloc.to_s}"
-      end
-    end
-
-    ActiveSupport.run_load_hooks(:skos_importer, self)
-  end
-end