ld4l-works_rdf 0.1.0

data/lib/ld4l/works_rdf/services/repository_services/populate_repository_from_graph.rb

@@ -0,0 +1,25 @@
+module LD4L
+  module WorksRDF
+    class PopulateRepositoryFromGraph
+
+      ##
+      # Create an RDF::Repository populated from an RDF::Graph.
+      #
+      # @param [RDF::Graph] instance of RDF::Graph
+      #
+      # @returns a populated instance of repository holding triples from the passed in graph
+      def self.call( graph )
+        raise ArgumentError, 'graph argument must an instance of RDF::Graph'  unless
+            graph.kind_of?(RDF::Graph)
+
+        repo_name = SecureRandom.uuid.to_sym
+        # r = RDF::Repository.new
+        r = ActiveTriples::Repositories.add_repository repo_name, RDF::Repository.new
+        r << graph
+      end
+
+    end
+  end
+end
+
+

data/lib/ld4l/works_rdf/version.rb

@@ -0,0 +1,5 @@
+module LD4L
+  module WorksRDF
+    VERSION = "0.1.0"
+  end
+end

data/lib/ld4l/works_rdf/vocab/bf.rb

@@ -0,0 +1,29 @@
+module RDFVocabularies
+  class BF < RDF::Vocabulary("http://bibframe.org/vocab/")
+    term :Work
+    term :Instance
+    term :Identifier
+    term :Organization
+    term :Place
+    term :Provider
+    term :Title
+
+    property :identifierScheme
+    property :identifierValue
+    property :instanceOf
+    property :instanceTitle
+    property :systemNumber
+    property :publication
+    property :providerStatement
+    property :copyrightDate
+    property :edition
+    property :label
+    property :providerDate
+    property :providerName
+    property :providerPlace
+    property :titleStatement
+    property :titleValue
+    property :subtitle
+    property :creator
+  end
+end

data/lib/ld4l/works_rdf/vocab/bgn.rb

@@ -0,0 +1,5 @@
+module RDFVocabularies
+  class BGN < RDF::Vocabulary("http://bibliograph.net/")
+    term :Agent
+  end
+end

data/lib/ld4l/works_rdf/vocab/bibo.rb

@@ -0,0 +1,10 @@
+module RDFVocabularies
+  class BIBO < RDF::Vocabulary("http://purl.org/ontology/bibo/")
+    term :Book
+    term :Document
+
+    property :isbn10
+    property :isbn13
+    property :oclcnum
+  end
+end

data/lib/ld4l/works_rdf/vocab/library.rb

@@ -0,0 +1,6 @@
+module RDFVocabularies
+  class LIBRARY < RDF::Vocabulary("http://purl.org/library/")
+    property :oclcnum
+    property :placeOfPublication
+  end
+end

data/lib/ld4l/works_rdf/vocab/vitro.rb

@@ -0,0 +1,5 @@
+module RDFVocabularies
+  class VITRO < RDF::Vocabulary("http://vitro.mannlib.cornell.edu/ns/vitro/0.7#")
+    property :mostSpecificType
+  end
+end

data/lib/ld4l/works_rdf/vocab/vivo.rb

@@ -0,0 +1,11 @@
+module RDFVocabularies
+  class VIVO < RDF::Vocabulary("http://vivoweb.org/ontology/core#")
+    term :Authorship
+
+    property :dateTimeValue
+    property :placeOfPublication
+    property :publisher
+    property :relatedBy
+    property :relates
+  end
+end

data/spec/ld4l/works_rdf/configuration_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+describe 'LD4L::WorksRDF' do
+
+  describe '#configuration' do
+    describe "base_uri" do
+      context "when base_uri is not configured" do
+        before do
+          class DummyWork < LD4L::WorksRDF::VivoBook
+            configure :type => RDFVocabularies::VIVO.Book, :base_uri => LD4L::WorksRDF.configuration.base_uri, :repository => :default
+          end
+        end
+        after do
+          Object.send(:remove_const, "DummyWork") if Object
+        end
+        it "should generate a Person URI using the default base_uri" do
+          expect(DummyWork.new('1').rdf_subject.to_s).to eq "http://localhost/1"
+        end
+      end
+
+      context "when uri ends with slash" do
+        before do
+          LD4L::WorksRDF.configure do |config|
+            config.base_uri = "http://localhost/test_slash/"
+          end
+          class DummyWork < LD4L::WorksRDF::VivoBook
+            configure :type => RDFVocabularies::VIVO.Book, :base_uri => LD4L::WorksRDF.configuration.base_uri, :repository => :default
+          end
+        end
+        after do
+          Object.send(:remove_const, "DummyWork") if Object
+          LD4L::WorksRDF.reset
+        end
+
+        it "should generate a Person URI using the configured base_uri" do
+          expect(DummyWork.new('1').rdf_subject.to_s).to eq "http://localhost/test_slash/1"
+        end
+      end
+
+      context "when uri does not end with slash" do
+        before do
+          LD4L::WorksRDF.configure do |config|
+            config.base_uri = "http://localhost/test_no_slash"
+          end
+          class DummyWork < LD4L::WorksRDF::VivoBook
+            configure :type => RDFVocabularies::VIVO.Book, :base_uri => LD4L::WorksRDF.configuration.base_uri, :repository => :default
+          end
+        end
+        after do
+          Object.send(:remove_const, "DummyWork") if Object
+          LD4L::WorksRDF.reset
+        end
+
+        it "should generate a Person URI using the configured base_uri" do
+          expect(DummyWork.new('1').rdf_subject.to_s).to eq "http://localhost/test_no_slash/1"
+        end
+      end
+
+      it "should return value of configured base_uri" do
+        LD4L::WorksRDF.configure do |config|
+          config.base_uri = "http://localhost/test_config/"
+        end
+        expect(LD4L::WorksRDF.configuration.base_uri).to eq "http://localhost/test_config/"
+      end
+
+      it "should return default base_uri when base_uri is reset" do
+        LD4L::WorksRDF.configure do |config|
+          config.base_uri = "http://localhost/test_config/"
+        end
+        expect(LD4L::WorksRDF.configuration.base_uri).to eq "http://localhost/test_config/"
+        LD4L::WorksRDF.configuration.reset_base_uri
+        expect(LD4L::WorksRDF.configuration.base_uri).to eq "http://localhost/"
+      end
+
+      it "should return default base_uri when all configs are reset" do
+        LD4L::WorksRDF.configure do |config|
+          config.base_uri = "http://localhost/test_config/"
+        end
+        expect(LD4L::WorksRDF.configuration.base_uri).to eq "http://localhost/test_config/"
+        LD4L::WorksRDF.reset
+        expect(LD4L::WorksRDF.configuration.base_uri).to eq "http://localhost/"
+      end
+    end
+
+    describe "localname_minter" do
+      context "when minter is nil" do
+        it "should use default minter in minter gem" do
+          localname = ActiveTriples::LocalName::Minter.generate_local_name(
+                  LD4L::WorksRDF::VivoBook, 10, {:prefix=>'default_'},
+                  LD4L::WorksRDF.configuration.localname_minter )
+          expect(localname).to be_kind_of String
+          expect(localname.size).to eq 44
+          expect(localname).to match /default_[a-zA-Z0-9]{8}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{12}/
+        end
+      end
+
+      context "when minter is configured" do
+        before do
+          LD4L::WorksRDF.configure do |config|
+            config.localname_minter = lambda { |prefix=""| prefix+'_configured_'+SecureRandom.uuid }
+          end
+          class DummyWork < LD4L::WorksRDF::VivoBook
+            configure :type => RDFVocabularies::VIVO.Book, :base_uri => LD4L::WorksRDF.configuration.base_uri, :repository => :default
+          end
+        end
+        after do
+          Object.send(:remove_const, "DummyWork") if Object
+          LD4L::WorksRDF.reset
+        end
+
+        it "should generate an Person URI using the configured localname_minter" do
+          localname = ActiveTriples::LocalName::Minter.generate_local_name(
+              LD4L::WorksRDF::VivoBook, 10,
+              LD4L::WorksRDF::VivoBook.localname_prefix,
+              &LD4L::WorksRDF.configuration.localname_minter )
+          expect(localname).to be_kind_of String
+          expect(localname.size).to eq 49
+          expect(localname).to match /w_configured_[a-zA-Z0-9]{8}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{12}/
+        end
+      end
+    end
+  end
+
+
+  describe "LD4L::WorksRDF::Configuration" do
+    describe "#base_uri" do
+      it "should default to localhost" do
+        expect(LD4L::WorksRDF::Configuration.new.base_uri).to eq "http://localhost/"
+      end
+
+      it "should be settable" do
+        config = LD4L::WorksRDF::Configuration.new
+        config.base_uri = "http://localhost/test"
+        expect(config.base_uri).to eq "http://localhost/test"
+      end
+
+      it "should be re-settable" do
+        config = LD4L::WorksRDF::Configuration.new
+        config.base_uri = "http://localhost/test/again"
+        expect(config.base_uri).to eq "http://localhost/test/again"
+        config.reset_base_uri
+        expect(config.base_uri).to eq "http://localhost/"
+      end
+    end
+
+    describe "#localname_minter" do
+      it "should default to nil" do
+        expect(LD4L::WorksRDF::Configuration.new.localname_minter).to eq nil
+      end
+
+      it "should be settable" do
+        config = LD4L::WorksRDF::Configuration.new
+        config.localname_minter = lambda { |prefix=""| prefix+'_configured_'+SecureRandom.uuid }
+        expect(config.localname_minter).to be_kind_of Proc
+      end
+
+      it "should be re-settable" do
+        config = LD4L::WorksRDF::Configuration.new
+        config.localname_minter = lambda { |prefix=""| prefix+'_configured_'+SecureRandom.uuid }
+        expect(config.localname_minter).to be_kind_of Proc
+        config.reset_localname_minter
+        expect(config.localname_minter).to eq nil
+      end
+    end
+  end
+end

data/spec/ld4l/works_rdf/models/books/vivo_book_rdf_spec.rb

@@ -0,0 +1,267 @@
+require 'spec_helper'
+
+describe 'LD4L::WorksRDF::VivoBook' do
+  # it_behaves_like 'an ActiveTriple::Resource'
+
+  subject { LD4L::WorksRDF::VivoBook.new }  # new virtual collection without a subject
+
+  describe 'rdf_subject' do
+    it "should be a blank node if we haven't set it" do
+      expect(subject.rdf_subject.node?).to be true
+    end
+
+    it "should be settable when it has not been set yet" do
+      subject.set_subject! RDF::URI('http://example.org/moomin')
+      expect(subject.rdf_subject).to eq RDF::URI('http://example.org/moomin')
+    end
+
+    it "should append to base URI when setting to non-URI subject" do
+      subject.set_subject! '123'
+      expect(subject.rdf_subject).to eq RDF::URI("#{LD4L::WorksRDF::VivoBook.base_uri}123")
+    end
+
+    describe 'when changing subject' do
+      before do
+        subject << RDF::Statement.new(subject.rdf_subject, RDF::DC.title, RDF::Literal('Comet in Moominland'))
+        subject << RDF::Statement.new(RDF::URI('http://example.org/moomin_comics'), RDF::DC.isPartOf, subject.rdf_subject)
+        subject << RDF::Statement.new(RDF::URI('http://example.org/moomin_comics'), RDF::DC.relation, 'http://example.org/moomin_land')
+        subject.set_subject! RDF::URI('http://example.org/moomin')
+      end
+
+      it 'should update graph subjects' do
+        expect(subject.has_statement?(RDF::Statement.new(subject.rdf_subject, RDF::DC.title, RDF::Literal('Comet in Moominland')))).to be true
+      end
+
+      it 'should update graph objects' do
+        expect(subject.has_statement?(RDF::Statement.new(RDF::URI('http://example.org/moomin_comics'), RDF::DC.isPartOf, subject.rdf_subject))).to be true
+      end
+
+      it 'should leave other uris alone' do
+        expect(subject.has_statement?(RDF::Statement.new(RDF::URI('http://example.org/moomin_comics'), RDF::DC.relation, 'http://example.org/moomin_land'))).to be true
+      end
+    end
+
+    describe 'created with URI subject' do
+      before do
+        subject.set_subject! RDF::URI('http://example.org/moomin')
+      end
+
+      it 'should not be settable' do
+        expect{ subject.set_subject! RDF::URI('http://example.org/moomin2') }.to raise_error
+      end
+    end
+  end
+
+
+  # -------------------------------------------------
+  #  START -- Test attributes specific to this model
+  # -------------------------------------------------
+
+  describe 'type' do
+    it "should be an RDFVocabularies::BIBO.Book" do
+      expect(subject.type.first.value).to eq RDFVocabularies::VIVO.Book.value
+    end
+  end
+
+  describe '#localname_prefix' do
+    it "should return default prefix" do
+      prefix = LD4L::WorksRDF::VivoBook.localname_prefix
+      expect(prefix).to eq "w"
+    end
+  end
+
+  # -----------------------------------------------
+  #  END -- Test attributes specific to this model
+  # -----------------------------------------------
+
+
+  describe "#persisted?" do
+    context 'with a repository' do
+      before do
+        # Create inmemory repository
+        repository = RDF::Repository.new
+        allow(subject).to receive(:repository).and_return(repository)
+      end
+
+      context "when the object is new" do
+        it "should return false" do
+          expect(subject).not_to be_persisted
+        end
+      end
+
+      context "when it is saved" do
+        before do
+          subject.persist!
+        end
+
+        it "should return true" do
+          expect(subject).to be_persisted
+        end
+      end
+    end
+  end
+
+  describe "#persist!" do
+    context "when the repository is set" do
+      context "and the item is not a blank node" do
+
+        subject {LD4L::WorksRDF::VivoBook.new("123")}
+        let(:result) { subject.persist! }
+
+        before do
+          # Create inmemory repository
+          @repo = RDF::Repository.new
+          ActiveTriples::Repositories.repositories[:default] = @repo
+          subject.place_of_publication = "NY"
+          result
+        end
+
+        it "should return true" do
+          expect(result).to eq true
+        end
+
+        it "should persist to the repository" do
+          expect(@repo.statements.first).to eq subject.statements.first
+        end
+
+        it "should delete from the repository" do
+          subject.reload
+          expect(subject.place_of_publication.first).to eq "NY"
+          subject.place_of_publication = []
+          expect(subject.place_of_publication).to eq []
+          subject.persist!
+          subject.reload
+          expect(@repo.statements.to_a.length).to eq 1 # Only the type statement
+        end
+      end
+    end
+  end
+
+  describe '#destroy!' do
+    before do
+      subject << RDF::Statement(RDF::DC.LicenseDocument, RDF::DC.title, 'LICENSE')
+    end
+
+    subject { LD4L::WorksRDF::VivoBook.new('456')}
+
+    it 'should return true' do
+      expect(subject.destroy!).to be true
+      expect(subject.destroy).to be true
+    end
+
+    it 'should delete the graph' do
+      subject.destroy
+      expect(subject).to be_empty
+    end
+  end
+
+  describe '#type' do
+    it 'should return the type configured on the parent class' do
+      expected_result = LD4L::WorksRDF::VivoBook.type.kind_of?(Array) ? LD4L::WorksRDF::VivoBook.type : [LD4L::WorksRDF::VivoBook.type]
+      expect(subject.type).to eq expected_result
+    end
+
+    it 'should set the type' do
+      subject.type = RDF::URI('http://example.org/AnotherClass')
+      expect(subject.type).to eq [RDF::URI('http://example.org/AnotherClass')]
+    end
+
+    it 'should be the type in the graph' do
+      subject.query(:subject => subject.rdf_subject, :predicate => RDF.type).statements do |s|
+        expect(s.object).to eq RDF::URI('http://example.org/AnotherClass')
+      end
+    end
+  end
+
+  describe '#rdf_label' do
+    subject {LD4L::WorksRDF::VivoBook.new("123")}
+
+    it 'should return an array of label values' do
+      expect(subject.rdf_label).to be_kind_of Array
+    end
+
+    it 'should return the default label as URI when no title property exists' do
+      expect(subject.rdf_label).to eq ["#{LD4L::WorksRDF::VivoBook.base_uri}123"]
+    end
+
+    it 'should prioritize configured label values' do
+      custom_label = RDF::URI('http://example.org/custom_label')
+      subject.class.configure :rdf_label => custom_label
+      subject << RDF::Statement(subject.rdf_subject, custom_label, RDF::Literal('New Label'))
+      expect(subject.rdf_label).to eq ['New Label']
+    end
+  end
+
+  describe 'big complex graphs' do
+    before do
+      class DummyPerson < ActiveTriples::Resource
+        configure :type => RDF::URI('http://example.org/Person')
+        property :foafname, :predicate => RDF::FOAF.name
+        property :publications, :predicate => RDF::FOAF.publications, :class_name => 'DummyDocument'
+        property :knows, :predicate => RDF::FOAF.knows, :class_name => DummyPerson
+      end
+
+      class DummyDocument < ActiveTriples::Resource
+        configure :type => RDF::URI('http://example.org/Document')
+        property :title, :predicate => RDF::DC.title
+        property :creator, :predicate => RDF::DC.creator, :class_name => 'DummyPerson'
+      end
+
+      LD4L::WorksRDF::VivoBook.property :item, :predicate => RDF::DC.relation, :class_name => DummyDocument
+    end
+
+    subject { LD4L::WorksRDF::VivoBook.new }
+
+    let (:document1) do
+      d = DummyDocument.new
+      d.title = 'Document One'
+      d
+    end
+
+    let (:document2) do
+      d = DummyDocument.new
+      d.title = 'Document Two'
+      d
+    end
+
+    let (:person1) do
+      p = DummyPerson.new
+      p.foafname = 'Alice'
+      p
+    end
+
+    let (:person2) do
+      p = DummyPerson.new
+      p.foafname = 'Bob'
+      p
+    end
+
+    let (:data) { <<END
+_:1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://example.org/SomeClass> .
+_:1 <http://purl.org/dc/terms/relation> _:2 .
+_:2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://example.org/Document> .
+_:2 <http://purl.org/dc/terms/title> "Document One" .
+_:2 <http://purl.org/dc/terms/creator> _:3 .
+_:2 <http://purl.org/dc/terms/creator> _:4 .
+_:4 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://example.org/Person> .
+_:4 <http://xmlns.com/foaf/0.1/name> "Bob" .
+_:3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://example.org/Person> .
+_:3 <http://xmlns.com/foaf/0.1/name> "Alice" .
+_:3 <http://xmlns.com/foaf/0.1/knows> _:4 ."
+END
+    }
+
+    after do
+      Object.send(:remove_const, "DummyDocument")
+      Object.send(:remove_const, "DummyPerson")
+    end
+
+    it 'should allow access to deep nodes' do
+      document1.creator = [person1, person2]
+      document2.creator = person1
+      person1.knows = person2
+      subject.item = [document1]
+      expect(subject.item.first.creator.first.knows.first.foafname).to eq ['Bob']
+    end
+  end
+end