active-triples 0.11.0 → 1.0.0.rc1

data/spec/active_triples/relation_spec.rb

@@ -203,6 +203,8 @@ describe ActiveTriples::Relation do
 
       types = { numeric: [0, 1, 2, 3_000_000_000],
                 string:  ['moomin', 'snork', 'snufkin'],
+                lang:    [RDF::Literal('Moomin', language: :en),
+                          RDF::Literal('Mummi', language: :fi)],
                 date:    [Date.today, Date.today - 1],
                 uri:     [RDF::URI('one'), RDF::URI('two'), RDF::URI('three')],
                 node:    [RDF::Node.new, RDF::Node.new],
@@ -239,6 +241,16 @@ describe ActiveTriples::Relation do
           other << 'extra'
           expect(subject <=> other).to be_nil
         end
+
+        it "gives nil when other contains a subset by language" do
+          subject << RDF::Literal("Moomin", language: :aa)
+          expect(subject <=> other).to be_nil
+        end
+
+        it "gives nil when other contains a superset by language" do
+          other << RDF::Literal("Moomin", language: :aa)
+          expect(subject <=> other).to be_nil
+        end
       end
     end
 
@@ -274,7 +286,7 @@ describe ActiveTriples::Relation do
     end
 
     it 'adds new child node to relation' do
-      expect { subject.build }.to change { subject.count }.by(1)
+      expect { subject.build }.to change { subject.count }.by 1
     end
 
     it 'builds child as new blank node by default' do
@@ -286,6 +298,24 @@ describe ActiveTriples::Relation do
       expect(subject.build(id: uri)).to be_uri
     end
 
+    context 'when cast is false' do
+      include_context 'with symbol property' do
+        before do
+          reflections.property :moomin,
+                               cast:       false,
+                               predicate:  RDF::Vocab::DC.relation
+        end
+      end
+
+      it 'still returns as a resource' do
+        expect(subject.build).to be_a ActiveTriples::RDFSource
+      end
+
+      it 'adds a new child node to the relation' do
+        expect { subject.build }.to change { subject.count }.by 1
+      end
+    end
+
     context 'with configured properties' do
       include_context 'with symbol property' do
         before do
@@ -320,6 +350,15 @@ describe ActiveTriples::Relation do
       expect { subject.delete(1) }.not_to change { subject.to_a }
     end
 
+    it 'does not notify observers when no changes are made' do
+      observer = double(:observer)
+      parent_resource.add_observer(observer)
+
+      expect(observer).not_to receive(:notify)
+
+      subject.delete(1)
+    end
+
     context 'with values' do
       before { subject << values }
 
@@ -337,6 +376,17 @@ describe ActiveTriples::Relation do
           .to contain_exactly(*values[1..-1])
       end
 
+      it 'notifies observers of changes' do
+        observer = double(:observer)
+        parent_resource.add_observer(observer)
+
+        expect(observer).to receive(:notify)
+          .with(subject.property,
+                a_collection_containing_exactly(*values[1..-1]))
+
+        subject.delete(values.first)
+      end
+
       it 'deletes a URI value' do
         values.delete(uri)
         expect { subject.delete(uri) }
@@ -364,11 +414,19 @@ describe ActiveTriples::Relation do
     include_context 'with symbol property'
 
     let(:parent_resource) { ActiveTriples::Resource.new }
+    let(:observer)        { double(:observer) }
 
     it 'gives nil for non-existant value' do
       expect(subject.delete?(1)).to be_nil
     end
 
+    it 'does not notify observers when no changes are made' do
+      parent_resource.add_observer(observer)
+
+      expect(observer).not_to receive(:notify)
+      subject.delete?(1)
+    end
+
     it 'returns value when deleted' do
       subject.set(1)
       expect(subject.delete?(1)).to eq 1
@@ -379,12 +437,23 @@ describe ActiveTriples::Relation do
       expect { subject.delete?(1) }
         .to change { subject.to_a }.to be_empty
     end
+
+    it 'notifies observers of changes' do
+      subject.set(1)
+      parent_resource.add_observer(observer)
+
+      expect(observer).to receive(:notify)
+        .with(subject.property, be_empty)
+
+      subject.delete?(1)
+    end
   end
 
   describe '#subtract' do
     include_context 'with symbol property'
 
     let(:parent_resource) { ActiveTriples::Resource.new }
+    let(:observer)        { double(:observer) }
 
     it 'subtracts values as arguments' do
       subject.set([1, 2, 3])
@@ -403,6 +472,16 @@ describe ActiveTriples::Relation do
       expect { subject.subtract([:two, :three]) }
         .to change { subject.to_a }.to contain_exactly(:one)
     end
+
+    it 'notifies observers of changes' do
+      subject.set([1, 2, 3])
+      parent_resource.add_observer(observer)
+
+      expect(observer).to receive(:notify)
+        .with(subject.property, a_collection_containing_exactly(1))
+
+      subject.subtract([2, 3])
+    end
   end
 
   describe '#swap' do
@@ -450,12 +529,32 @@ describe ActiveTriples::Relation do
         expect { subject.clear }
           .to change { subject.parent.query(query_pattern) }.to([])
       end
+
+      it 'notifies observers of changed state' do
+        observer = double(:observer)
+        parent_resource.add_observer(observer)
+
+        expect(observer)
+          .to receive(:notify)
+          .with(subject.property, be_empty)
+
+        subject.clear
+      end
     end
 
     it 'is a no-op when relation is empty' do
       subject.parent << [subject.parent.rdf_subject, RDF.type, 'moomin']
       expect { subject.clear }.not_to change { subject.parent.statements.to_a }
     end
+
+    it 'does not notify observers when relation is empty' do
+      observer = double(:observer)
+      parent_resource.add_observer(observer)
+
+      expect(observer).not_to receive(:notify)
+
+      subject.clear
+    end
   end
 
   describe '#<<' do
@@ -474,6 +573,19 @@ describe ActiveTriples::Relation do
         .to change { subject.to_a }.to contain_exactly(*values)
     end
 
+    it 'notifies observers on the parent' do
+      observer = double(:observer)
+      values   = [:moomin, :snork]
+      parent_resource.add_observer(observer)
+
+      expect(observer)
+        .to receive(:notify)
+        .with(subject.property,
+              a_collection_containing_exactly(*values))
+
+      subject << values
+    end
+
     it 'keeps datatypes' do
       values = [RDF::Literal(Date.today), RDF::Literal(:moomin)]
 
@@ -506,8 +618,8 @@ describe ActiveTriples::Relation do
       end
 
       it 'retains unknown datatypes' do
-        literal = 
-          RDF::Literal('snowflake', 
+        literal =
+          RDF::Literal('snowflake',
                        datatype: RDF::URI('http://emaple.com/snowflake'))
 
         subject << literal
@@ -531,7 +643,7 @@ describe ActiveTriples::Relation do
           literal = DummySnowflake.new('special')
 
           subject << literal
-          
+
           expect { subject << 'special' }
             .to change { subject.send(:objects).to_a }
                  .to contain_exactly(literal, RDF::Literal('special'))
@@ -641,18 +753,81 @@ describe ActiveTriples::Relation do
               .to contain_exactly(*values)
           end
 
-          context 'and persistence_strategy is configured' do
+          context 'and a class is configured' do
+            let(:this_type) { RDF::URI('http://example.org/Moomin') }
+            let(:this_class) do
+              Class.new do
+                include ActiveTriples::RDFSource
+                configure type: RDF::URI('http://example.org/Moomin')
+              end
+            end
+
+            let(:other_type) { RDF::URI('http://example.org/Snork') }
+            let(:other_class) do
+              Class.new do
+                include ActiveTriples::RDFSource
+                configure type: RDF::URI('http://example.org/Snork')
+              end
+            end
+
             before do
               reflections
-                .property :moomin,
-                          predicate: RDF::URI('http://example.org/moomin'),
-                          persist_to: ActiveTriples::RepositoryStrategy
+                .property property,
+                          class_name: this_class,
+                          predicate:  RDF::URI('http://example.org/moomin')
             end
 
-            it 'assigns persistence strategy' do
-              subject.each.each do |node|
-                expect(node.persistence_strategy)
-                  .to be_a ActiveTriples::RepositoryStrategy
+            it 'casts values with no type to the class' do
+              expect(subject).to contain_exactly(an_instance_of(this_class),
+                                                 an_instance_of(this_class),
+                                                 an_instance_of(this_class))
+            end
+
+            it 'casts values with other type to the other class' do
+              subject << other_class.new
+              expect(subject).to contain_exactly(an_instance_of(this_class),
+                                                 an_instance_of(this_class),
+                                                 an_instance_of(this_class),
+                                                 an_instance_of(other_class))
+            end
+          end
+
+          context 'and persistence_strategy is configured' do
+            context 'as a repository strategy' do
+              before do
+                reflections
+                  .property :moomin,
+                            predicate: RDF::URI('http://example.org/moomin'),
+                            persist_to: ActiveTriples::RepositoryStrategy
+              end
+
+              it 'assigns persistence strategy' do
+                subject.each do |node|
+                  expect(node.persistence_strategy)
+                    .to be_a ActiveTriples::RepositoryStrategy
+                end
+              end
+            end
+
+            context 'as a parent strategy' do
+              before do
+                reflections
+                  .property :moomin,
+                            predicate: RDF::URI('http://example.org/moomin'),
+                            persist_to: ActiveTriples::ParentStrategy
+              end
+
+              it 'assigns persistence strategy' do
+                subject.each do |node|
+                  expect(node.persistence_strategy)
+                    .to be_a ActiveTriples::ParentStrategy
+                end
+              end
+
+              it 'assigns parent' do
+                subject.each do |node|
+                  expect(node.persistence_strategy.parent).to eql subject.parent
+                end
               end
             end
           end
@@ -767,6 +942,18 @@ describe ActiveTriples::Relation do
           .to change { subject.to_a }.to contain_exactly(*values)
       end
 
+      it 'notifies observers on the parent' do
+        observer = double(:observer)
+        values   = [:moomin, :snork]
+        parent_resource.add_observer(observer)
+
+        expect(observer)
+          .to receive(:notify)
+          .with(subject.property, a_collection_containing_exactly(*values))
+
+        subject.set(values)
+      end
+
       context 'when given a Relation' do
         before do
           class DummySnowflake < RDF::Literal

data/spec/active_triples/resource_spec.rb

@@ -635,6 +635,121 @@ describe ActiveTriples::Resource do
     end
   end
 
+  describe 'sources with properties with class_name defined' do
+    before(:context) do
+      class DummyChapter < ActiveTriples::Resource
+        ontology = RDF::URI('http://www.example.com/ontology')
+        type     = RDF::URI('http://www.example.com/type')
+
+        configure repository: :default, type: type / 'Chapter'
+
+        property :title,    predicate: ontology / 'title'
+        property :subtitle, predicate: ontology / 'subtitle'
+      end
+
+      class DummyBook < ActiveTriples::Resource
+        ontology = RDF::URI('http://www.example.com/ontology')
+        type     = RDF::URI('http://www.example.com/type')
+
+        configure repository: :default, type: type / 'Book'
+
+        property :title,       predicate: ontology / 'title'
+        property :has_chapter, predicate: ontology / 'hasChapter',
+                               class_name: DummyChapter
+      end
+    end
+
+    context 'when loading models from graph' do
+      before(:context) do
+        r = RDF::Repository.new
+        ActiveTriples::Repositories.repositories[:default] = r
+
+        @book_url = 'http://www.example.com/BOOK_URI'
+        @book_title = 'Example Book.'
+        @chapter_title = 'Chapter 1'
+        ttl = "<#{@book_url}> a <http://www.example.com/type/Book>;
+                 <http://www.example.com/ontology/hasChapter> [
+                   a <http://www.example.com/type/Chapter>;
+                   <http://www.example.com/ontology/title> \"#{@chapter_title}\"
+                 ];
+               <http://www.example.com/ontology/title> \"#{@book_title}\" ."
+        book_graph = ::RDF::Graph.new.from_ttl ttl
+        r = ActiveTriples::Repositories.repositories[:default]
+        r << book_graph
+
+        @book = DummyBook.new(RDF::URI.new(@book_url))
+      end
+
+      it 'populates DummyBook properly' do
+        expect(@book.rdf_subject.to_s).to eq @book_url
+        expect(@book).to be_a DummyBook
+        expect(@book.type)
+          .to include(RDF::URI.new('http://www.example.com/type/Book'))
+        expect(@book.title.first).to eq @book_title
+      end
+
+      it 'populates DummyChapter properly' do
+        chapter = @book.has_chapter.first
+        expect(chapter).to be_a DummyChapter
+        expect(chapter.title.first).to eq @chapter_title
+        expect(chapter.type)
+          .to include(RDF::URI.new('http://www.example.com/type/Chapter'))
+      end
+    end
+
+    context 'when loading models through properties' do
+      before(:context) do
+        r = RDF::Repository.new
+        ActiveTriples::Repositories.repositories[:default] = r
+
+        bk1 = DummyBook.new('http://www.example.com/book1')
+        bk1.title = 'Learning about Explicit Links in ActiveTriples'
+
+        ch1 = DummyChapter.new('http://www.example.com/book1/chapter1')
+        ch1.title = 'Defining a source with an Explicit Link'
+        bk1.has_chapter = ch1
+        ch1.persist!
+        bk1.persist!
+
+        @bk1 = DummyBook.new('http://www.example.com/book1')
+        @ch1 = DummyChapter.new('http://www.example.com/book1/chapter1')
+      end
+
+      it 'populates DummyBook (resumed resource) properly' do
+        expect(@bk1.type.first)
+          .to eq RDF::URI('http://www.example.com/type/Book')
+        expect(@bk1.title.first)
+          .to eq 'Learning about Explicit Links in ActiveTriples'
+      end
+
+      it 'populates DummyChapter (property resource) properly' do
+        ch1 = @bk1.has_chapter.first
+        expect(ch1.type.first)
+          .to eq RDF::URI('http://www.example.com/type/Chapter')
+        expect(ch1.title.first)
+          .to eq 'Defining a source with an Explicit Link'
+      end
+
+      it 'populates DummyChapter (directly from repository) properly' do
+        expect(@ch1.type.first)
+          .to eq RDF::URI('http://www.example.com/type/Chapter')
+        expect(@ch1.title.first)
+          .to eq 'Defining a source with an Explicit Link'
+      end
+
+      it 'does not reload from repository twice' do
+        ch1 = @bk1.has_chapter.first
+        expect(ch1.title.first).to eq 'Defining a source with an Explicit Link'
+
+        @ch1.subtitle = 'Changed after original load'
+        @ch1.persist!
+        expect(@ch1.subtitle).to eq ['Changed after original load']
+
+        expect(ch1.subtitle).to eq []
+      end
+    end
+  end
+
   describe 'big complex graphs' do
     before do
       class DummyPerson