rof 1.0.7 → 1.2.0

data/spec/lib/rof/translators/fedora_to_rof_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+RSpec.describe ROF::Translators::FedoraToRof do
+  let(:outfile) { double(close: true, write: true) }
+  let(:pid) { 'und:dev0012829m' }
+  let(:config) { { fedora_connection_information: fedora_connection_information } }
+  let(:fedora_connection_information) { { url: 'http://localhost:8080/fedora', user: 'fedoraAdmin', password: 'fedoraAdmin' } }
+
+  it 'will fail to initialize without a valid fedora connection' do
+    allow(Rubydora).to receive(:connect).with(fedora_connection_information).and_raise('Woof')
+    expect { described_class.new([pid], config) }.to raise_error('Woof')
+  end
+
+  describe '.call' do
+    it "retrieves a fedora object and converts it to ROF" do
+      expected_output = [{
+        "pid" => "und:dev0012829m",
+        "type" => "fobject",
+        "af-model" => "GenericFile",
+        "rels-ext" => {
+          "@context"=> ROF::RelsExtRefContext,
+          "@id" => "und:dev0012829m",
+          "isPartOf"=> "und:dev00128288"
+        },
+        "rights" => {
+          "read-groups" => ["registered"],
+          "edit" => ["dbrower"]
+        },
+        "properties-meta" => {"mime-type" => "text/xml"},
+        "properties" => "<fields>\n<depositor>batch_ingest</depositor>\n<owner>dbrower</owner>\n</fields>\n",
+        "content-meta" => {"label"=>"bonnie+chauncey", "mime-type"=>"application/octet-stream", "URL"=>"http://libvirt9.library.nd.edu:14000/item/dev0012826k/bonnie+chauncey"},
+        "metadata" => {
+          "@context"=> {
+             "bibo"=>"http://purl.org/ontology/bibo/",
+             "dc"=>"http://purl.org/dc/terms/",
+             "ebucore"=>"http://www.ebu.ch/metadata/ontologies/ebucore/ebucore#",
+             "foaf"=>"http://xmlns.com/foaf/0.1/",
+             'hydramata-rel' => 'http://projecthydra.org/ns/relations#',
+             "mrel"=>"http://id.loc.gov/vocabulary/relators/",
+             "ms" => 'http://www.ndltd.org/standards/metadata/etdms/1.1/',
+             "nd"=>"https://library.nd.edu/ns/terms/",
+             "rdfs"=>"http://www.w3.org/2000/01/rdf-schema#",
+             'ths' => 'http://id.loc.gov/vocabulary/relators/',
+             "vracore"=>"http://purl.org/vra/",
+             "pav"=>"http://purl.org/pav/",
+             "dc:dateSubmitted" => {"@type" => "http://www.w3.org/2001/XMLSchema#date"},
+             "dc:created"=>{"@type"=>"http://www.w3.org/2001/XMLSchema#date"},
+             "dc:modified" => {"@type" => "http://www.w3.org/2001/XMLSchema#date"}
+          },
+          "@id" => "info:fedora/und:dev0012829m",
+          "dc:dateSubmitted" => "2016-04-12Z",
+          "dc:modified" => "2016-04-12Z",
+          "dc:title" => "bonnie+chauncey"
+        },
+        "bendo-item" => "dev0012826k",
+        "characterization-meta" => {"mime-type"=>"text/xml"},
+        "thumbnail-meta" => {"label"=>"File Datastream", "mime-type"=>"image/png"},
+      }]
+      VCR.use_cassette("fedora_to_rof1") do
+        expect(described_class.call([pid], config)).to eq(expected_output)
+      end
+    end
+  end
+end

data/spec/lib/rof/translators/jsonld_to_rof/accumulator_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+require 'rof/translators/jsonld_to_rof/accumulator'
+module ROF
+  module Translators
+    module JsonldToRof
+      RSpec.describe Accumulator do
+        describe '#add_pid' do
+          it 'sets the pid if non has been set' do
+            subject.add_pid('abcd')
+            expect(subject.to_rof.fetch('pid')).to eq('abcd')
+          end
+          it 'raises an exception if a different pid is set with the same accumulator' do
+            subject.add_pid('abcd')
+            expect { subject.add_pid('hijk') }.to raise_error(described_class::PidAlreadySetError)
+          end
+          it 'ignores attempts to set the same pid over and over' do
+            subject.add_pid('abcd')
+            expect { subject.add_pid('abcd') }.not_to change { subject.to_rof }
+          end
+        end
+        describe '#add_predicate_location_and_value' do
+          it 'will register a pid if one is given' do
+            subject.add_predicate_location_and_value(['pid'], 1)
+            expect(subject.to_rof).to eq({ "pid" => 1 })
+          end
+          it 'will not allow another pid to be register if it is different' do
+            subject.add_pid('abc')
+            expect { subject.add_predicate_location_and_value(['pid'], 1) }.to raise_error(described_class::PidAlreadySetError)
+          end
+          it 'wraps values in an array' do
+            subject.add_predicate_location_and_value(['hello'], 1)
+            expect(subject.to_rof).to eq({ "hello" => [1] })
+            subject.add_predicate_location_and_value(['hello'], 2)
+            expect(subject.to_rof).to eq({ "hello" => [1, 2] })
+          end
+          it 'handles deep locations' do
+            subject.add_predicate_location_and_value(['hello', 'world'], "value")
+            expect(subject.to_rof).to eq({ "hello" => { "world" => ["value"] } })
+          end
+
+          it 'handles locations at different levels' do
+            subject.add_predicate_location_and_value(['hello', 'world'], "value")
+            subject.add_predicate_location_and_value(['kitchen'], "another")
+            expect(subject.to_rof).to eq({ "hello" => { "world" => ["value"] }, "kitchen" => ["another"] } )
+          end
+
+          context 'handling blank nodes' do
+            context 'for the same node' do
+              it 'collects values for the same location' do
+                blank_node = RDF::Node.new('_b0')
+                subject.add_blank_node(RDF::Statement.new(blank_node, nil, nil))
+                subject.add_predicate_location_and_value(['parent', 'child'], "value", blank_node)
+                subject.add_predicate_location_and_value(['parent', 'child'], "another", blank_node)
+                expect(subject.to_rof).to eq({
+                  "parent" => [{
+                    "child" => ["value", "another"]
+                  }]
+                })
+              end
+
+              it 'collects values for the same deep location' do
+                blank_node = RDF::Node.new('_b0')
+                subject.add_blank_node(RDF::Statement.new(blank_node, nil, nil))
+                subject.add_predicate_location_and_value(['parent', 'child', 'grandchild'], "value", blank_node)
+                subject.add_predicate_location_and_value(['parent', 'child', 'grandchild'], "another", blank_node)
+                expect(subject.to_rof).to eq({
+                  "parent" => {
+                    "child" => [{
+                      "grandchild" => ["value", "another"]
+                    }]
+                  }
+                })
+              end
+
+              it 'collects values for the same location' do
+                blank_node = RDF::Node.new('_b0')
+                subject.add_blank_node(RDF::Statement.new(blank_node, nil, nil))
+                subject.add_predicate_location_and_value(['parent'], "value", blank_node)
+                subject.add_predicate_location_and_value(['parent'], "another", blank_node)
+                expect(subject.to_rof).to eq({
+                  "parent" => ["value", "another"]
+                })
+              end
+
+              it 'merges different locations' do
+                blank_node = RDF::Node.new('_b0')
+                subject.add_blank_node(RDF::Statement.new(blank_node, nil, nil))
+                subject.add_predicate_location_and_value(['parent', 'child_one'], "value", blank_node)
+                subject.add_predicate_location_and_value(['parent', 'child_two'], "another", blank_node)
+                expect(subject.to_rof).to eq({
+                  "parent" => [{
+                    "child_one" => ["value"],
+                    "child_two" => ["another"]
+                  }]
+                })
+              end
+            end
+
+            context 'for different nodes' do
+              it 'separates them in the JSON output' do
+                blank_node_1 = RDF::Node.new('_b0')
+                blank_node_2 = RDF::Node.new('_b1')
+                subject.add_blank_node(RDF::Statement.new(blank_node_1, nil, nil))
+                subject.add_blank_node(RDF::Statement.new(blank_node_2, nil, nil))
+                subject.add_predicate_location_and_value(['parent', 'child'], "value", blank_node_1)
+                subject.add_predicate_location_and_value(['parent', 'child'], "another", blank_node_2)
+                expect(subject.to_rof).to eq({
+                  "parent" => [{
+                    "child" => ["value"]
+                  }, {
+                    "child" => ["another"]
+                  }]
+                })
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/rof/translators/jsonld_to_rof/predicate_handler_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+require 'rof/translators/jsonld_to_rof/predicate_handler'
+module ROF
+  module Translators
+    module JsonldToRof
+      RSpec.describe PredicateHandler do
+        around do |spec|
+          # Ensuring that we preserve duplication of
+          previous_registry = described_class.send(:registry)
+          described_class.send(:clear_registry!)
+          described_class.register('https://library.nd.edu/ns/terms/') do |handler|
+            handler.map('accessRead', to: ['rights', 'read'])
+          end
+          described_class.register('http://purl.org/dc/terms/') do |handler|
+            handler.namespace_prefix('dc:')
+            handler.map('dateTime', to: ['nested', 'dateTime'])
+            handler.within(['metadata'])
+          end
+          described_class.register('http://www.ndltd.org/standards/metadata/etdms/1.1/') do |handler|
+            handler.within(['ms:degree'])
+            handler.namespace_prefix('ms:')
+            handler.map('block-key') do |object, accumulator|
+              accumulator.add_predicate_location_and_value('from-block', object)
+            end
+            handler.map('something', to: ['metadata', 'ms:something'], force: true)
+            handler.map('something', to: ['another', 'somewhere'])
+          end
+          spec.run
+          described_class.send(:clear_registry!, previous_registry)
+        end
+
+        describe '.call' do
+          let(:object) { 'my-object' }
+          let(:accumulator) { Accumulator.new }
+
+          it 'handles multiple map imperatives' do
+            described_class.call('http://www.ndltd.org/standards/metadata/etdms/1.1/something', object, accumulator)
+            expect(accumulator.to_rof).to eq({
+              "metadata" => { "ms:something" => [object] },
+              "ms:degree" => { "another" => { "ms:somewhere" => [object] } }
+            })
+          end
+
+          it 'handles force option' do
+            described_class.call('https://library.nd.edu/ns/terms/accessRead', object, accumulator)
+            expect(accumulator.to_rof).to eq({ "rights" => { "read" => ["my-object"] } })
+          end
+
+          it 'handles the block option' do
+            described_class.call('http://www.ndltd.org/standards/metadata/etdms/1.1/block-key', 'value' , accumulator)
+            expect(accumulator.to_rof).to eq({ "from-block" => ["value"] })
+          end
+
+          it 'handles mixture of implicit and explicit terms using within and namespace_prefix' do
+            described_class.call('http://purl.org/dc/terms/title', 'my-title', accumulator)
+            described_class.call('http://purl.org/dc/terms/dateTime', 'my-dateTime', accumulator)
+            expect(accumulator.to_rof).to eq({
+              "metadata" => { "dc:title" => ["my-title"], "nested" => { "dc:dateTime" => ["my-dateTime"] } }
+            })
+          end
+
+          context 'with an unregistred url' do
+            it 'will raise an exception' do
+              expect do
+                expect { described_class.call('http://the.unhandled.com', 'my-title', accumulator) }.to raise_error(described_class::UnhandledPredicateError)
+              end.not_to change { accumulator.to_rof }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/rof/translators/jsonld_to_rof/predicate_object_handler_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'rof/translators/jsonld_to_rof/predicate_object_handler'
+
+module ROF
+  module Translators
+    module JsonldToRof
+      RSpec.describe PredicateObjectHandler do
+        let(:accumulator) { Accumulator.new }
+        let(:rdf_predicate) { RDF::URI.new("http://purl.org/dc/terms/title") }
+        describe '.call' do
+          subject { described_class.call(rdf_predicate, rdf_object, accumulator) }
+          context 'for an RDF::URI' do
+            let(:rdf_object) { RDF::URI.new("http://curate.nd.edu/show/1234") }
+            it 'accumulates the value' do
+              subject
+              expect(accumulator.to_rof.fetch('metadata').fetch('dc:title')).to eq(['und:1234'])
+            end
+          end
+          context 'for an RDF::Literal' do
+            let(:rdf_object) { RDF::Literal.new("Hello World") }
+            it 'accumulates the value' do
+              subject
+              expect(accumulator.to_rof.fetch('metadata').fetch('dc:title')).to eq(['Hello World'])
+            end
+          end
+          context 'for an RDF::Node' do
+            let(:rdf_subject) { RDF::Node.new('_b0') }
+            let(:rdf_object) { RDF::Node.new('_b0') }
+            let(:rdf_predicate) { RDF::URI.new("http://www.ndltd.org/standards/metadata/etdms/1.1/") }
+            it 'expands the blank nodes already accumulated values' do
+              statement = RDF::Statement.new(subject: rdf_object, predicate: RDF::URI.new('http://www.ndltd.org/standards/metadata/etdms/1.1/name'), object: RDF::Literal.new('Awesome Sauce'))
+              accumulator.add_blank_node(statement)
+              subject
+              expect(accumulator.to_rof.fetch('metadata').fetch('ms:degree')).to eq([{ "ms:name" => ['Awesome Sauce'] }])
+            end
+          end
+
+          context 'for an unhandled object type' do
+            let(:rdf_object) { double }
+            it 'raises an error' do
+              expect { subject }.to raise_error(described_class::UnknownRdfObjectTypeError)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/rof/translators/jsonld_to_rof/statement_handler_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'rof/translators/jsonld_to_rof/statement_handler'
+require 'rof/translators/jsonld_to_rof/accumulator'
+
+module ROF
+  module Translators
+    module JsonldToRof
+      RSpec.describe StatementHandler do
+        let(:accumulator) { Accumulator.new }
+        let(:statement) { RDF::Statement.new(subject: rdf_subject, predicate: rdf_predicate, object: rdf_object) }
+        let(:rdf_predicate) { RDF::URI.new("http://purl.org/dc/terms/title") }
+        let(:rdf_object) { RDF::Literal.new("Hello World") }
+        describe '.call' do
+          subject { described_class.call(statement, accumulator) }
+          context 'for a URI subject' do
+            let(:pid) { 'abcd1234' }
+            let(:rdf_subject) { RDF::URI.new("https://curate.nd.edu/show/#{pid}") }
+            it 'accumulates the pid' do
+              subject
+              expect(accumulator.to_rof.fetch('pid')).to eq("und:#{pid}")
+            end
+          end
+          context 'for a Node subject' do
+            let(:rdf_subject) { RDF::Node.new("_b1") }
+            it 'does not accumulate a pid' do
+              subject
+              expect(accumulator.to_rof.key?('pid')).to eq(false)
+            end
+          end
+          context 'for a something else' do
+            let(:rdf_subject) { nil }
+            it 'raises an error' do
+              expect { subject }.to raise_error(described_class::UnhandledRdfSubjectError)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/rof/translators/jsonld_to_rof_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+module ROF
+  module Translators
+    # ```console
+    # ssh app@sipity.library.nd.edu
+    # cd /mnt/curatend-batch/production/success
+    # find . -maxdepth 2 -name '*.rof' -type f | xargs grep -l <pid>
+    # ```
+    RSpec.describe JsonldToRof do
+      describe '.call' do
+        [
+          '2j62s467216',
+          'js956d59913',
+          'xg94hm53h0c',
+          '0g354f18610',
+          '2v23vt16z2z',
+          'h989r21069m',
+          'cr56n01253w',
+          'm039k358q5c',
+          'zk51vd69n1r',
+          'nk322b9161g',
+          'p8418k7430d'
+        ].each do |noid|
+          context "with JSON-LD from NOID=#{noid} CurateND work that was ingested via the batch ingester" do
+            it 'will return ROF that is a subset of the ROF used by the batch ingestor' do
+              rof_generated_via_batch = normalize_rof(noid)
+
+              jsonld_from_curatend = JSON.load(File.read(File.join(GEM_ROOT, "spec/fixtures/jsonld_to_rof/#{noid}.jsonld")))
+              expected_output = Array.wrap(rof_generated_via_batch)
+              actual_output = described_class.call(jsonld_from_curatend, {})
+              keys = (actual_output.first.keys + expected_output.first.keys).uniq
+              expected_rof = {}
+              actual_rof = {}
+              keys.each do |key|
+                actual_metadata = normalize(actual_output.first.fetch(key, {}))
+                actual_rof[key] = actual_metadata
+
+                expected_metadata = normalize(expected_output.first.fetch(key, {}))
+                expected_rof[key] = expected_metadata
+                # We may have {} for one, and [] for another. In this case, both are empty, so we'll skip.
+                next if actual_metadata.empty? && expected_metadata.empty?
+                expect(actual_metadata).to eq(expected_metadata), "Mismatch on #{key}.\n\tJSON-LD: #{actual_metadata.inspect}\n\tROF: #{expected_metadata.inspect}"
+              end
+              comparer = ROF::CompareRof.new(actual_rof, expected_rof, skip_rels_ext_context: true)
+              expect(comparer.compare_rights).to eq(0)
+              expect(comparer.compare_rels_ext).to eq(0)
+              expect(comparer.compare_metadata).to eq(0)
+              expect(comparer.compare_everything_else).to eq(0)
+            end
+          end
+        end
+
+        def normalize_rof(noid)
+          path_to_rof = File.read(File.join(GEM_ROOT, "spec/fixtures/jsonld_to_rof/#{noid}.rof"))
+
+          # Normalizing some of the @context entries to reflect JSON-LD entries
+          if path_to_rof.include?('"ths": "http://id.loc.gov/vocabulary/relators/"')
+            path_to_rof.gsub!('"ths": "http://id.loc.gov/vocabulary/relators/"', '"mrel": "http://id.loc.gov/vocabulary/relators/"')
+            path_to_rof.gsub!('"ths:', '"mrel:')
+          end
+          rof = JSON.load(path_to_rof)
+          # Removing @id as they are superflous
+          rof[0]['metadata'].delete('@id') if rof[0].key?('metadata')
+          rof[0]['rels-ext'].delete('@id') if rof[0].key?('rels-ext')
+          rof
+        end
+
+
+        # @todo For any key with an empty array, delete that key
+        # Responsible for normalizing a Hash or non-Hash
+        def normalize(input)
+          if input.is_a?(Hash)
+            returning_hash = {}
+            input.keys.sort.each do |key|
+              raw_value = input[key]
+              next if key == '@context' # Because Sipity's ROF context was messed up
+              Array.wrap(raw_value).each do |value|
+                returning_hash[key] ||= []
+                if value.is_a?(Hash)
+                  hash = {}
+                  value.keys.sort.each do |sorted_key|
+                    hash[sorted_key] ||= []
+                    Array.wrap(value[sorted_key]).sort.each do |sorted_value|
+                      hash[sorted_key] << normalize_string(sorted_value.dup)
+                    end
+                  end
+                  value = hash
+                else
+                  normalize_string(value)
+                end
+                returning_hash[key] << value
+              end
+              begin
+                returning_hash[key] = returning_hash[key].sort if returning_hash[key].respond_to?(:sort)
+              rescue ArgumentError
+                returning_hash[key]
+              end
+              # next unless returning_hash[key].present?
+              if returning_hash[key]
+                returning_hash[key] = returning_hash[key].reject(&:empty?)
+                returning_hash.delete(key) if returning_hash[key].empty?
+              end
+            end
+            returning_hash
+          else
+            Array.wrap(input).map { |obj| normalize_string(obj) }
+          end
+        end
+
+        def normalize_string(input)
+          # Forcing escaped unicode hexadecimal to the "human" readable format
+          input.gsub!(/\\u([0-F]{4})/) { '' << Regexp.last_match[1].to_i(16) }
+          input.gsub!("\n", '')
+          input
+        end
+      end
+    end
+  end
+end