ladder 0.2.1 → 0.3.0

data/spec/ladder/resource/dynamic_spec.rb

@@ -6,170 +6,172 @@ describe Ladder::Resource::Dynamic do
     Mongoid.logger.level = Moped.logger.level = Logger::DEBUG
     Mongoid.purge!
 
-    LADDER_BASE_URI = 'http://example.org'
+    LADDER_BASE_URI ||= 'http://example.org'
 
     class Thing
       include Ladder::Resource::Dynamic
     end
-
-    class Person
-      include Ladder::Resource::Dynamic
-    end
   end
 
-  it_behaves_like 'a Resource'
+  after do
+    Object.send(:remove_const, :LADDER_BASE_URI) if Object
+    Object.send(:remove_const, "Thing") if Object
+  end
 
-  shared_context 'with data' do
+  context 'with data' do
     let(:subject) { Thing.new }
 
     before do
       # non-localized literal
       subject.class.field :alt
-      subject.class.property :alt, :predicate => RDF::DC.alternative
+      subject.class.property :alt, predicate: RDF::DC.alternative
       subject.alt = 'Mumintrollet pa kometjakt'
 
       # localized literal
-      subject.class.property :title, :predicate => RDF::DC.title
+      subject.class.property :title, predicate: RDF::DC.title
       subject.title = 'Comet in Moominland'
     end
-  end
-
-  describe '#property' do
-    include_context 'with data'
 
-    context 'with undefined property' do
-      before do
-        subject.property :description, :predicate => RDF::DC.description
-        subject.description = "Second in Tove Jansson's series of Moomin books"
+    it_behaves_like 'a Resource'
+    
+    describe '#property' do
+      context 'with undefined property' do
+        before do
+          subject.property :description, predicate: RDF::DC.description
+          subject.description = "Second in Tove Jansson's series of Moomin books"
+        end
+
+        it 'should create a context' do
+          expect(subject._context).to eq({description: RDF::DC.description.to_uri.to_s})
+        end
+      
+        it 'should build an accessor' do
+          expect(subject.description).to eq "Second in Tove Jansson's series of Moomin books"
+        end
       end
 
-      it 'should create a context' do
-        expect(subject._context).to eq({:description => RDF::DC.description.to_uri.to_s})
-      end
+      context 'with conflicting property' do
+        before do
+          subject.property :title, predicate: RDF::DC11.title
+          subject.dc11_title = "Kometjakten"
+        end
+
+        it 'should create a context' do
+          expect(subject._context).to eq({dc11_title: RDF::DC11.title.to_uri.to_s})
+        end
       
-      it 'should build an accessor' do
-        expect(subject.description).to eq "Second in Tove Jansson's series of Moomin books"
+        it 'should build an accessor' do
+          expect(subject.dc11_title).to eq "Kometjakten"
+        end
       end
     end
-
-    context 'with conflicting property' do
+  
+    describe '#update_resource' do
       before do
-        subject.property :title, :predicate => RDF::DC11.title
+        # undefined property
+        subject.property :description, predicate: RDF::DC.description
+        subject.description = "Second in Tove Jansson's series of Moomin books"
+
+        # conflicting property
+        subject.property :title, predicate: RDF::DC11.title
         subject.dc11_title = "Kometjakten"
-      end
 
-      it 'should create a context' do
-        expect(subject._context).to eq({:dc11_title => RDF::DC11.title.to_uri.to_s})
+        # defined field
+        subject << RDF::Statement(nil, RDF::DC.title, 'Kometen kommer')
+
+        # conflicting property
+        subject << RDF::Statement(nil, RDF::DC.alternative, "Kometjakten")
+
+        # URI value
+        subject << RDF::Statement(nil, RDF::DC.identifier, RDF::URI('http://some.uri'))
+
+        subject.update_resource
       end
-      
-      it 'should build an accessor' do
-        expect(subject.dc11_title).to eq "Kometjakten"
+    
+      it 'should have updated values' do
+        expect(subject.resource.statements.count).to eq 5
+        expect(subject.resource.query(predicate: RDF::DC.description, object: "Second in Tove Jansson's series of Moomin books").count).to eq 1
+        expect(subject.resource.query(predicate: RDF::DC11.title, object: "Kometjakten").count).to eq 1
+        expect(subject.resource.query(predicate: RDF::DC.title, object: RDF::Literal.new('Kometen kommer', language: :en)).count).to eq 1
+        expect(subject.resource.query(predicate: RDF::DC.alternative, object: "Kometjakten").count).to eq 1
+        expect(subject.resource.query(predicate: RDF::DC.identifier, object: RDF::URI('http://some.uri')).count).to eq 1
       end
     end
-  end
-
-  describe '#<<' do
-    include_context 'with data'
 
-    context 'with defined field' do
-      before do
-        subject << RDF::Statement(nil, RDF::DC.title, 'Kometen kommer')
-      end
+    describe '#<<' do
+      context 'with defined field' do
+        before do
+          subject << RDF::Statement(nil, RDF::DC.title, 'Kometen kommer')
+        end
       
-      it 'should not create a context' do
-        expect(subject._context).to be nil
-      end
+        it 'should not create a context' do
+          expect(subject._context).to be nil
+        end
       
-      it 'should update existing values' do
-        expect(subject.title).to eq 'Kometen kommer'
+        it 'should update existing values' do
+          expect(subject.title).to eq 'Kometen kommer'
+        end
       end
-    end
 
-    context 'with undefined field' do
-      before do
-        subject << RDF::Statement(nil, RDF::DC.description, "Second in Tove Jansson's series of Moomin books")
-      end
+      context 'with undefined field' do
+        before do
+          subject << RDF::Statement(nil, RDF::DC.description, "Second in Tove Jansson's series of Moomin books")
+        end
 
-      it 'should create a context' do
-        expect(subject._context).to eq({:description => RDF::DC.description.to_uri.to_s})
-      end
+        it 'should create a context' do
+          expect(subject._context).to eq({ description: RDF::DC.description.to_uri.to_s })
+        end
       
-      it 'should build an accessor' do
-        expect(subject.description).to eq "Second in Tove Jansson's series of Moomin books"
+        it 'should build an accessor' do
+          expect(subject.description).to eq "Second in Tove Jansson's series of Moomin books"
+        end
       end
-    end
 
-    context 'with conflicting field' do
-      before do
-        subject << RDF::Statement(nil, RDF::DC11.title, "Kometjakten")
-      end
+      context 'with conflicting property' do
+        before do
+          subject << RDF::Statement(nil, RDF::DC11.title, "Kometjakten")
+        end
 
-      it 'should create a context' do
-        expect(subject._context).to eq({:dc11_title => RDF::DC11.title.to_uri.to_s})
-      end
+        it 'should create a context' do
+          expect(subject._context).to eq({ dc11_title: RDF::DC11.title.to_uri.to_s })
+        end
       
-      it 'should build an accessor' do
-        expect(subject.dc11_title).to eq "Kometjakten"
+        it 'should build an accessor' do
+          expect(subject.dc11_title).to eq "Kometjakten"
+        end
       end
-    end
 
+      context 'with a URI value' do
+        before do
+          subject << RDF::Statement(nil, RDF::DC.identifier, RDF::URI('http://some.uri'))
+        end
+      
+        it 'should store the URI as a string' do
+          expect(subject.identifier).to eq 'http://some.uri'
+        end
 
-    context 'with a URI value' do
+        it 'should cast a URI into the resource' do
+          subject.update_resource
+          query = subject.resource.query(subject: subject.rdf_subject, predicate: RDF::DC.identifier)
+          expect(query.first_object).to be_a_kind_of RDF::URI
+        end
+      end
+    end
+    
+    describe '#resource_class' do
       before do
-        subject << RDF::Statement(nil, RDF::DC.identifier, RDF::URI('http://some.uri'))
-        subject.update_resource
+        subject.property :description, predicate: RDF::DC.description
       end
-      
-      it 'should store the URI as a string' do
-        expect(subject.identifier).to eq 'http://some.uri'
+
+      it 'should have modified properties on the instance' do
+        expect(subject.resource.class.properties.keys).to include 'description'
       end
       
-      it 'should cast a URI into the resource' do
-        query = subject.resource.query(:subject => subject.rdf_subject, :predicate => RDF::DC.identifier)
-        expect(query.count).to eq 1
-        expect(query.first_object).to be_a_kind_of RDF::URI
+      it 'should not modify the global class properties' do
+        expect(subject.class.resource_class.properties.keys).to_not include 'description'
+        expect(subject.class.resource_class.properties).to eq subject.class.new.class.resource_class.properties
       end
     end
-
   end
-  
-  describe '#update_resource' do
-    include_context 'with data'
-
-    before do
-      # undefined property
-      subject.property :description, :predicate => RDF::DC.description
-      subject.description = "Second in Tove Jansson's series of Moomin books"
-
-      # conflicting property
-      subject.property :title, :predicate => RDF::DC11.title
-      subject.dc11_title = "Kometjakten"
 
-      # defined field
-      subject << RDF::Statement(nil, RDF::DC.title, 'Kometen kommer')
-
-      # conflicting field
-      subject << RDF::Statement(nil, RDF::DC.alternative, "Kometjakten")
-
-      # URI value
-      subject << RDF::Statement(nil, RDF::DC.identifier, RDF::URI('http://some.uri'))
-
-      subject.update_resource
-    end
-    
-    it 'should have updated values' do
-      expect(subject.resource.statements.count).to eq 5
-      expect(subject.resource.query(:predicate => RDF::DC.description, :object => "Second in Tove Jansson's series of Moomin books").count).to eq 1
-      expect(subject.resource.query(:predicate => RDF::DC11.title, :object => "Kometjakten").count).to eq 1
-      expect(subject.resource.query(:predicate => RDF::DC.title, :object => RDF::Literal.new('Kometen kommer', :language => :en)).count).to eq 1
-      expect(subject.resource.query(:predicate => RDF::DC.alternative, :object => "Kometjakten").count).to eq 1
-      expect(subject.resource.query(:predicate => RDF::DC.identifier, :object => RDF::URI('http://some.uri')).count).to eq 1
-    end
-  end
-
-  after do
-    Object.send(:remove_const, :LADDER_BASE_URI) if Object
-    Object.send(:remove_const, "Thing") if Object
-    Object.send(:remove_const, "Person") if Object
-  end
 end

data/spec/ladder/resource_spec.rb

@@ -6,22 +6,287 @@ describe Ladder::Resource do
     Mongoid.logger.level = Moped.logger.level = Logger::DEBUG
     Mongoid.purge!
 
-    LADDER_BASE_URI = 'http://example.org'
+    LADDER_BASE_URI ||= 'http://example.org'
 
     class Thing
       include Ladder::Resource
     end
-
-    class Person
-      include Ladder::Resource
-    end
   end
 
-  it_behaves_like 'a Resource'
-
   after do
     Object.send(:remove_const, :LADDER_BASE_URI) if Object
     Object.send(:remove_const, "Thing") if Object
-    Object.send(:remove_const, "Person") if Object
   end
+
+  shared_context 'with data' do
+    before do
+      subject.class.configure type: RDF::DC.BibliographicResource
+
+      # non-localized literal
+      subject.class.field :alt
+      subject.class.property :alt, predicate: RDF::DC.alternative
+      subject.alt = 'Mumintrollet pa kometjakt'
+
+      # localized literal
+      subject.class.property :title, predicate: RDF::DC.title
+      subject.title = 'Comet in Moominland'
+    end
+  end
+
+  shared_context 'with relations' do
+    let(:person)  { Person.new }
+    let(:concept) { Concept.new }
+    let(:part)    { Part.new }
+    
+    before do
+      class Person
+        include Ladder::Resource
+      end
+
+      class Concept
+        include Ladder::Resource
+      end
+
+      class Part
+        include Ladder::Resource
+      end
+
+      person.class.configure type: RDF::DC.AgentClass
+      concept.class.configure type: RDF::SKOS.Concept
+      part.class.configure type: RDF::DC.PhysicalResource
+
+      # many-to-many
+      person.class.property :things, predicate: RDF::DC.relation, class_name: 'Thing'
+      subject.class.property :people, predicate: RDF::DC.creator, class_name: 'Person'
+      subject.people << person
+
+      # one-sided has-many
+      subject.class.has_and_belongs_to_many :concepts, inverse_of: nil
+      subject.class.property :concepts, predicate: RDF::DC.subject, class_name: 'Concept'
+      subject.concepts << concept
+
+      # embedded one
+      part.class.embedded_in :thing
+      part.class.property :thing, predicate: RDF::DC.relation, class_name: 'Thing'
+      subject.class.embeds_one :part, cascade_callbacks: true
+      subject.class.property :part, predicate: RDF::DC.hasPart, class_name: 'Part'
+      subject.part = part
+      subject.save
+    end
+
+    after do
+      Object.send(:remove_const, "Person") if Object
+      Object.send(:remove_const, 'Concept') if Object
+      Object.send(:remove_const, 'Part') if Object
+    end
+
+    it 'should have relations' do
+      expect(subject.people.to_a).to include person
+      expect(subject.concepts.to_a).to include concept
+      expect(subject.part).to eq part
+    end
+
+    it 'should have inverse relations' do
+      expect(person.things.to_a).to include subject
+      expect(concept.relations).to be_empty
+      expect(part.thing).to eq subject
+    end
+
+    context 'with many-to-many' do
+      it 'should have a relation' do
+        expect(subject.relations['people'].relation).to eq (Mongoid::Relations::Referenced::ManyToMany)
+        expect(subject.people.to_a).to include person
+      end
+
+      it 'should have an inverse relation' do
+        expect(person.relations['things'].relation).to eq (Mongoid::Relations::Referenced::ManyToMany)
+        expect(person.things.to_a).to include subject
+      end
+
+      it 'should have a valid predicate' do
+        expect(subject.class.properties['people'].predicate).to eq RDF::DC.creator
+      end
+
+      it 'should have a valid inverse predicate' do
+        expect(person.class.properties['things'].predicate).to eq RDF::DC.relation
+      end
+    end
+
+    context 'with one-sided has-many' do
+      it 'should have a relation' do
+        expect(subject.relations['concepts'].relation).to eq (Mongoid::Relations::Referenced::ManyToMany)
+        expect(subject.concepts.to_a).to include concept
+      end
+
+      it 'should not have an inverse relation' do
+        expect(subject.relations['concepts'].inverse_of).to be nil
+        expect(concept.relations).to be_empty
+      end
+
+      it 'should have a valid predicate' do
+        expect(subject.class.properties['concepts'].predicate).to eq RDF::DC.subject
+      end
+
+      it 'should not have an inverse predicate' do
+        expect(concept.class.properties).to be_empty
+      end
+    end
+
+    context 'with embedded-one' do
+      it 'should have a relation' do
+        expect(subject.relations['part'].relation).to eq (Mongoid::Relations::Embedded::One)
+        expect(subject.part).to eq part
+      end
+
+      it 'should have an inverse relation' do
+        expect(part.relations['thing'].relation).to eq (Mongoid::Relations::Embedded::In)
+        expect(part.thing).to eq subject
+      end
+
+      it 'should have a valid predicate' do
+        expect(subject.class.properties['part'].predicate).to eq RDF::DC.hasPart
+      end
+
+      it 'should have a valid inverse predicate' do
+        expect(part.class.properties['thing'].predicate).to eq RDF::DC.relation
+      end
+    end
+    
+    context '#update_resource with related' do
+      # TODO add tests for autosaved relations
+      before do
+        subject.update_resource(related: true)
+      end
+
+      it 'should have a literal object' do
+        query = subject.resource.query(subject: subject.rdf_subject, predicate: RDF::DC.title)
+        expect(query.first_object.to_s).to eq 'Comet in Moominland'
+      end
+
+      it 'should have an embedded object' do
+        query = subject.resource.query(subject: subject.rdf_subject, predicate: RDF::DC.hasPart)
+        expect(query.count).to eq 1
+        expect(query.first_object).to eq part.rdf_subject
+      end
+
+      it 'should have an embedded object relation' do
+        query = subject.resource.query(subject: part.rdf_subject, predicate: RDF::DC.relation)
+        expect(query.count).to eq 1
+        expect(query.first_object).to eq subject.rdf_subject
+      end
+
+      it 'should have related objects' do
+        # many-to-many
+        query_creator = subject.resource.query(subject: subject.rdf_subject, predicate: RDF::DC.creator)
+        expect(query_creator.count).to eq 1
+        expect(query_creator.first_object).to eq person.rdf_subject
+
+        # one-sided has-many
+        query_subject = subject.resource.query(subject: subject.rdf_subject, predicate: RDF::DC.subject)
+        expect(query_subject.count).to eq 1
+        expect(query_subject.first_object).to eq concept.rdf_subject
+
+        # embedded-one
+        query_part = subject.resource.query(subject: subject.rdf_subject, predicate: RDF::DC.hasPart)
+        expect(query_part.count).to eq 1
+        expect(query_part.first_object).to eq part.rdf_subject
+      end
+
+      it 'should have related object relations' do
+        # many-to-many
+        query = person.resource.query(subject: person.rdf_subject, predicate: RDF::DC.relation)
+        expect(query.count).to eq 1
+        expect(query.first_object).to eq subject.rdf_subject
+        
+        # one-sided has-many
+        expect(concept.resource.query(object: subject.rdf_subject)).to be_empty
+
+        # embedded-one
+        query = part.resource.query(subject: part.rdf_subject, predicate: RDF::DC.relation)
+        expect(query.count).to eq 1
+        expect(query.first_object).to eq subject.rdf_subject
+      end
+    end
+
+    context '#update_resource with related and then without related' do
+      # TODO add tests for autosaved relations
+      before do
+        subject.update_resource(related: true)
+        subject.update_resource # implicit false
+      end
+
+      it 'should not have related objects' do
+        expect(subject.resource.query(subject: person.rdf_subject)).to be_empty
+        expect(subject.resource.query(subject: concept.rdf_subject)).to be_empty
+      end
+      
+      it 'should have embedded object relations' do
+        query = subject.resource.query(subject: part.rdf_subject, predicate: RDF::DC.relation)
+        expect(query.count).to eq 1
+        expect(query.first_object).to eq subject.rdf_subject
+      end
+
+      it 'should have related object relations' do
+        # many-to-many
+        query = person.resource.query(subject: person.rdf_subject, predicate: RDF::DC.relation)
+        expect(query.count).to eq 1
+        expect(query.first_object).to eq subject.rdf_subject
+        
+        # one-sided has-many
+        expect(concept.resource.query(object: subject.rdf_subject)).to be_empty
+
+        # embedded-one
+        query = part.resource.query(subject: part.rdf_subject, predicate: RDF::DC.relation)
+        expect(query.count).to eq 1
+        expect(query.first_object).to eq subject.rdf_subject
+      end
+    end
+
+    context 'serializable' do
+      # TODO: contexts with relations and without
+#      expect(subject.as_jsonld(related: true)).to eq subject.as_jsonld
+#      expect(subject.as_qname(related: true)).to eq subject.as_qname
+#      expect(subject.as_framed_jsonld).to eq subject.as_jsonld
+
+      describe '#as_jsonld related: true' do
+        it 'should output a valid jsonld representation of itself and related' do
+          graph = RDF::Graph.new << JSON::LD::API.toRdf(subject.as_jsonld related: true)
+          expect(subject.update_resource(related: true).to_hash).to eq graph.to_hash
+        end
+      end
+
+      describe '#as_qname related: true' do
+        it 'should output a valid qname representation of itself and related' do
+          # TODO
+        end
+      end
+
+      describe '#as_framed_jsonld' do
+        it 'should output a valid framed jsonld representation of itself and related' do
+          framed_graph = RDF::Graph.new << JSON::LD::API.toRdf(subject.as_framed_jsonld)
+          related_graph = RDF::Graph.new << JSON::LD::API.toRdf(subject.as_jsonld related: true)          
+          expect(framed_graph.to_hash).to eq related_graph.to_hash
+        end
+      end
+    end
+
+  end
+
+  context 'with data' do
+    let(:subject) { Thing.new }
+
+    include_context 'with data'
+
+    it_behaves_like 'a Resource'
+  end
+
+  context 'with relations' do
+    let(:subject) { Thing.new }
+
+    include_context 'with data'
+    include_context 'with relations'
+
+    it_behaves_like 'a Resource'
+  end
+
 end