iqvoc 4.3.3 → 4.4.0

data/lib/iqvoc/navigation.rb

@@ -43,8 +43,8 @@ module Iqvoc
     # 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 => []
+        text: proc { t('txt.views.navigation.extensions') },
+        items: []
       }
 
       if position && !items[position][:items]

data/lib/iqvoc/origin.rb

@@ -49,55 +49,20 @@ module Iqvoc
         end
       end
 
-      class UmlautReplacer < GenericFilter
+      class UriConformanceFilter < GenericFilter
         def call(obj, str)
-          str = str.gsub(/Ö/, 'Oe').
-            gsub(/Ä/, 'Ae').
-            gsub(/Ü/, 'Ue').
-            gsub(/ö/, 'oe').
-            gsub(/ä/, 'ae').
-            gsub(/ü/, 'ue').
-            gsub(/ß/, 'ss')
+          str = str.parameterize # basic url conformance
 
-          run(obj, str)
-        end
-      end
-
-      class WhitespaceReplacer < GenericFilter
-        def call(obj, str)
-          str = str.gsub(/\s([a-zA-Z])?/) do
-            $1.to_s.upcase
-          end
-
-          run(obj, str)
-        end
-      end
-
-      class SpecialCharReplacer < GenericFilter
-        def call(obj, str)
-          str = str.gsub(/[(\[:]/, "--").
-            gsub(/[)\]'""]/, "").
-            gsub(/[,\.\/&;]/, '-')
-
-          run(obj, str)
-        end
-      end
-
-      class LeadingNumberHandler < GenericFilter
-        def call(obj, str)
+          # prefix with '_' if origin starts with digit
           str = str.gsub(/^[0-9].*$/) do |match|
             "_#{match}"
           end
-
           run(obj, str)
         end
       end
 
-      @filters = ActiveSupport::OrderedHash.new
-      @filters[:replace_umlauts]        = UmlautReplacer
-      @filters[:replace_whitespace]     = WhitespaceReplacer
-      @filters[:replace_special_chars]  = SpecialCharReplacer
-      @filters[:handle_leading_numbers] = LeadingNumberHandler
+      @filters = {}
+      @filters[:uri_conformance_filter] = UriConformanceFilter
 
       def self.register(name, klass)
         @filters[name.to_sym] = klass
@@ -140,8 +105,7 @@ module Iqvoc
     end
 
     def inspect
-      "#<Iqvoc::Origin:0x%08x>" % object_id
+      '#<Iqvoc::Origin:0x%08x>' % object_id
     end
-
   end
 end

data/lib/iqvoc/rankable.rb

@@ -29,6 +29,5 @@ module Iqvoc
         'partials/concept/relation/edit_ranked'
       end
     end
-
   end
 end

data/lib/iqvoc/rdf_sync.rb

@@ -1,18 +1,18 @@
 # encoding: UTF-8
 
 class Iqvoc::RDFSync
-  delegate :url_helpers, :to => "Rails.application.routes"
+  delegate :url_helpers, to: 'Rails.application.routes'
 
   ADAPTORS = { # XXX: inappropriate?
-    "virtuoso" => lambda do  |host_url, options|
+    'virtuoso' => lambda do  |host_url, options|
       require 'iq_triplestorage/virtuoso_adaptor'
       return IqTriplestorage::VirtuosoAdaptor.new(host_url, options)
     end,
-    "sesame" => lambda do |host_url, options|
+    'sesame' => lambda do |host_url, options|
       require 'iq_triplestorage/sesame_adaptor'
-      host_url, _, repo = host_url.rpartition("/repositories/")
+      host_url, _, repo = host_url.rpartition('/repositories/')
       if host_url.blank? || repo.blank?
-       raise ArgumentError, "missing repository in Sesame URL"
+       raise ArgumentError, 'missing repository in Sesame URL'
       end
       options[:repository] = repo
       return IqTriplestorage::SesameAdaptor.new(host_url, options)
@@ -26,7 +26,7 @@ class Iqvoc::RDFSync
     @password = options[:password]
     @batch_size = options[:batch_size] || 100
     @view_context = options[:view_context] # XXX: not actually optional
-    raise(ArgumentError, "missing view context") unless @view_context # XXX: smell (see above)
+    raise(ArgumentError, 'missing view context') unless @view_context # XXX: smell (see above)
   end
 
   def all # TODO: rename
@@ -57,14 +57,14 @@ class Iqvoc::RDFSync
   def push(records)
     data = records.inject({}) do |memo, record|
       graph_uri = url_helpers.rdf_url(record.origin,
-          :host => URI.parse(@base_url).host, :format => nil, :lang => nil)
+          host: URI.parse(@base_url).host, format: nil, lang: nil)
       memo[graph_uri] = serialize(record)
       memo
     end
 
-    adaptor_type = "sesame" # XXX: hard-coded
-    adaptor = ADAPTORS[adaptor_type].call(@target_url, :username => @username,
-        :password => @password)
+    adaptor_type = 'sesame' # XXX: hard-coded
+    adaptor = ADAPTORS[adaptor_type].call(@target_url, username: @username,
+        password: @password)
     return adaptor.batch_update(data)
   end
 
@@ -73,8 +73,9 @@ class Iqvoc::RDFSync
     # view in order to get to the RDF serialization
 
     doc = IqRdf::Document.new(@base_url)
-    Iqvoc.default_rdf_namespace_helper_methods.each do |meth|
-      doc.namespaces(@view_context.send(meth))
+    RdfNamespacesHelper.instance_methods.each do |meth|
+      namespaces = @view_context.send(meth)
+      doc.namespaces(namespaces) if namespaces.is_a?(Hash)
     end
 
     rdf_helper = Object.new.extend(RdfHelper)
@@ -90,7 +91,7 @@ class Iqvoc::RDFSync
   # yields batches of candidates for synchronization
   def gather_candidates # TODO: rename
     Iqvoc::Sync.syncable_classes.each do |klass|
-      self.class.candidates(klass).find_in_batches(:batch_size => @batch_size) do |records|
+      self.class.candidates(klass).find_in_batches(batch_size: @batch_size) do |records|
         yield records
       end
     end
@@ -102,18 +103,15 @@ class Iqvoc::RDFSync
     return klass ? klass.published.unsynced :
         Iqvoc::Sync.syncable_classes.map { |klass| candidates(klass) }
   end
-
 end
 
 module Iqvoc::RDFSync::Helper # TODO: rename -- XXX: does not belong here!?
-
   def triplestore_syncer
-    base_url = root_url(:lang => nil) # XXX: brittle in the face of future changes?
+    base_url = root_url(lang: nil) # XXX: brittle in the face of future changes?
 
-    return Iqvoc::RDFSync.new(base_url, Iqvoc.config["triplestore.url"],
-        :username => Iqvoc.config["triplestore.username"].presence,
-        :password => Iqvoc.config["triplestore.password"].presence,
-        :view_context => view_context) # fugly, but necessary; cf. RDFSync#serialize
+    return Iqvoc::RDFSync.new(base_url, Iqvoc.config['triplestore.url'],
+        username: Iqvoc.config['triplestore.username'].presence,
+        password: Iqvoc.config['triplestore.password'].presence,
+        view_context: view_context) # fugly, but necessary; cf. RDFSync#serialize
   end
-
 end

data/lib/iqvoc/rdfapi.rb

@@ -36,6 +36,7 @@ module Iqvoc
     end
 
     URI_REGEXP = /^https?:\/\/[^\s]+$/
+    LITERAL_REGEXP = /^"(.+)"(@(.+))?$/
 
     def self.devour(rdf_subject, rdf_predicate, rdf_object)
       case rdf_predicate
@@ -46,7 +47,7 @@ module Iqvoc
         else
           target = rdf_object
         end
-        target.find_or_initialize_by(:origin => rdf_subject)
+        target.find_or_initialize_by(origin: rdf_subject)
       when String
         # dictionary lookup
         target = PREDICATE_DICTIONARY[rdf_predicate] || rdf_predicate.constantize
@@ -55,6 +56,5 @@ module Iqvoc
         rdf_predicate.build_from_rdf(rdf_subject, rdf_predicate, rdf_object)
       end
     end
-
   end
 end

data/lib/iqvoc/skos_exporter.rb

@@ -0,0 +1,153 @@
+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

@@ -2,21 +2,37 @@ 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
 
-    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::Concept.root_class] +
-        [Iqvoc::Collection.member_class]
-
-    def initialize(file, default_namespace_url, logger = Rails.logger, publish = true)
-      @file = file
+    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)
@@ -25,10 +41,10 @@ module Iqvoc
 
       # 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 => ":"
+        '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|
@@ -39,22 +55,22 @@ module Iqvoc
 
       # 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.instance
+      @seen_first_level_objects[Iqvoc::Concept.root_class.instance.origin] = Iqvoc::Concept.root_class
 
-      @new_subjects = [] # Concepts to be published later
+      @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 remebered it's prefLabel...
-      @unknown_second_level_triples = []
+      #     :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
-      Iqvoc::RDFAPI::FIRST_LEVEL_OBJECT_CLASSES.each do |klass|
+      first_level_object_classes.each do |klass|
         klass.select('origin').load.each do |thing|
           @existing_origins[thing.origin] = klass
         end
@@ -72,47 +88,69 @@ module Iqvoc
 
       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_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_object_classes.each do |klass|
         second_level_types["#{klass.rdf_namespace}:#{klass.rdf_predicate}"] = klass
       end
 
-      file.each do |line|
-        identify_blank_nodes(*extract_triple(line)) ||
-            import_first_level_objects(first_level_types, *extract_triple(line)) ||
-            import_second_level_objects(second_level_types, false, *extract_triple(line))
+      @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
 
-      @logger.debug "Computing 'forward' defined triples..."
-      @unknown_second_level_triples.each do |s, p, o|
-        import_second_level_objects(second_level_types, true, s, p, o)
+      # 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.debug "Basic import done (took #{(first_import_step_done - start).to_i} seconds)."
+      @logger.info "Basic import done (took #{(first_import_step_done - start).to_i} seconds)."
 
       published = publish
 
       done = Time.now
-      @logger.debug "Publishing of #{published} subjects done (took #{(done - first_import_step_done).to_i} seconds). #{@new_subjects.count - published} are in draft state."
-      puts "Imported #{published} published and #{@new_subjects.count - published} draft subjects in #{(done - start).to_i} seconds."
-      puts "  First step took #{(first_import_step_done - start).to_i} seconds, publishing took #{(done - first_import_step_done).to_i} seconds."
+      @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.debug "Publishing #{@new_subjects.count} new subjects..."
-        @new_subjects.each do |subject|
-          if subject.valid_with_full_validation?
-            subject.publish
-            subject.save!
+        @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}"
@@ -133,7 +171,7 @@ module Iqvoc
     end
 
     def import_first_level_objects(types, subject, predicate, object)
-      if (predicate == "rdf:type" && types[object] && subject =~ /^:(.+)$/)
+      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
 
@@ -144,8 +182,14 @@ module Iqvoc
             @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
-          @seen_first_level_objects[origin] = types[object].create!(:origin => origin)
-          @new_subjects << @seen_first_level_objects[origin]
+          @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
@@ -153,10 +197,10 @@ module Iqvoc
       end
     end
 
-    def import_second_level_objects(types, final, subject, predicate, object)
-      return unless (subject =~ /^:(.*)$/ && types[predicate]) # We're not responsible for this
+    def import_second_level_objects(types, final, line)
+      subject, predicate, object = *extract_triple(line)
 
-      initial_triple = [subject, predicate, object]
+      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
@@ -165,7 +209,7 @@ module Iqvoc
         if final
           @logger.warn "Iqvoc::SkosImporter: Couldn't find Subject with origin '#{subject_origin}. Skipping entry '#{subject} #{predicate} #{object}.'"
         else
-          @unknown_second_level_triples << initial_triple
+          @unknown_second_level_triples << line
         end
         return false
       end
@@ -176,9 +220,9 @@ module Iqvoc
         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}.'"
+            @logger.warn "Iqvoc::SkosImporter: Couldn't find Object with origin '#{object_origin}'. Skipping entry ':#{subject_origin} #{predicate} #{object_origin}.'"
           else
-            @unknown_second_level_triples << initial_triple
+            @unknown_second_level_triples << line
           end
           return false
         end
@@ -194,14 +238,14 @@ module Iqvoc
         if final
           object = @blank_nodes[object]
         else
-          @unknown_second_level_triples << initial_triple
+          @unknown_second_level_triples << line
           return false
         end
       end
       begin
         types[predicate].build_from_rdf(subject, predicate, object)
       rescue InvalidStringLiteralError => e
-        warn e.message
+        @logger.warn e.message
       end
     end
 
@@ -209,11 +253,15 @@ module Iqvoc
       unless @seen_first_level_objects[origin]
         klass = @existing_origins[origin]
         if klass
-          @seen_first_level_objects[origin] = klass.by_origin(origin).last
+          @seen_first_level_objects[origin] = klass
         end
       end
 
-      @seen_first_level_objects[origin]
+      # FIXME: bang
+      # FIXME: return something?
+      if klass = @seen_first_level_objects[origin]
+        klass.find_by!(origin: origin)
+      end
     end
 
     def blank_node?(str)
@@ -229,7 +277,7 @@ module Iqvoc
       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(".", "_")
+            @prefixes[uri_prefix] + $1.gsub('.', '_')
           end
         end
         e.squish!
@@ -237,11 +285,32 @@ module Iqvoc
           ":#{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
+
     ActiveSupport.run_load_hooks(:skos_importer, self)
   end
-
 end