active-triples 0.10.2 → 0.11.0

data/lib/active_triples/util/buffered_transaction.rb

@@ -0,0 +1,126 @@
+require 'active_triples/util/extended_bounded_description'
+
+module ActiveTriples
+  ##
+  # A buffered trasaction for use with `ActiveTriples::ParentStrategy`.
+  #
+  # If an `ActiveTriples::RDFSource` instance is passed as the underlying 
+  # repository, this transaction will try to find an existing 
+  # `BufferedTransaction` to use as the basis for a snapshot. When the 
+  # transaction is executed, the inserts and deletes are replayed against the
+  # `RDFSource`.
+  #
+  # If a `RDF::Transaction::TransactionError` is raised on commit, this 
+  # transaction optimistically attempts to replay the changes.
+  #
+  # Reads are projected onto a specialized "Extended Bounded Description" 
+  # subgraph. 
+  #
+  # @see ActiveTriples::Util::ExtendedBoundedDescription
+  class BufferedTransaction < 
+        RDF::Repository::Implementation::SerializedTransaction
+    # @!attribute snapshot [r]
+    #   @return RDF::Dataset
+    # @!attribute subject [r]
+    #   @return RDF::Term
+    # @!attribute ancestors [r]
+    #   @return Array<RDF::Term>
+    attr_reader :snapshot, :subject, :ancestors
+    
+    def initialize(repository,
+                   ancestors:  [],
+                   subject:    nil, 
+                   graph_name: nil, 
+                   mutable:    false, 
+                   **options,
+                   &block)
+      @subject   = subject
+      @ancestors = ancestors
+
+      if repository.is_a?(RDFSource)
+        if repository.persistence_strategy.graph.is_a?(BufferedTransaction)
+          super
+          @snapshot = repository.persistence_strategy.graph.snapshot
+          return
+        else
+          repository = repository.persistence_strategy.graph.data
+        end
+      end
+
+      return super
+    end
+
+    ##
+    # Provides :repeatable_read isolation (???)
+    #
+    # @see RDF::Transaction#isolation_level
+    def isolation_level
+      :repeatable_read
+    end
+
+    ##
+    # @return [BufferedTransaction] self
+    def data
+      self
+    end
+
+    ##
+    # @see RDF::Mutable#supports
+    def supports?(feature)
+      return true if feature.to_sym == :snapshots
+    end
+
+    ##
+    # Adds statement to the `inserts` collection of the buffered changeset and
+    # updates the snapshot.
+    #
+    # @see RDF::Mutable#insert_statement
+    def insert_statement(statement)
+      @changes.insert(statement)
+      @changes.deletes.delete(statement)
+      super
+    end
+
+    ##
+    # Adds statement to the `deletes` collection of the buffered changeset and
+    # updates the snapshot.
+    #
+    # @see RDF::Transaction#delete_statement
+    def delete_statement(statement)
+      @changes.delete(statement)
+      @changes.inserts.delete(statement)
+      super
+    end
+
+    ##
+    # Executes optimistically. If errors are encountered, we replay the buffer 
+    # on the latest version.
+    # 
+    # If the `repository` is a transaction, we immediately replay the buffer 
+    # onto it.
+    #
+    # @see RDF::Transaction#execute
+    def execute
+      raise TransactionError, 'Cannot execute a rolled back transaction. ' \
+                              'Open a new one instead.' if @rolledback
+      return if changes.empty?
+      return super unless repository.is_a?(ActiveTriples::RDFSource)
+
+      repository.insert(changes.inserts)
+      repository.delete(changes.deletes)
+    rescue RDF::Transaction::TransactionError => err
+      raise err if @rolledback
+
+      # replay changest on the current version of the repository
+      repository.delete(*changes.deletes)
+      repository.insert(*changes.inserts)
+    end
+
+    private
+    
+    def read_target
+      return super unless subject
+      ExtendedBoundedDescription.new(super, subject, ancestors)
+    end
+  end
+end

data/lib/active_triples/util/extended_bounded_description.rb

@@ -0,0 +1,75 @@
+module ActiveTriples
+  ##
+  # Bounds the scope of an `RDF::Queryable` to a subgraph defined from a source 
+  # graph, a starting node, and a list of "ancestors" terms, by the following 
+  # process:
+  #
+  # Include in the subgraph:
+  #  1. All statements in the source graph where the subject of the statement 
+  #     is the starting node.
+  #  2. Add the starting node to the ancestors list.
+  #  2. Recursively, for all statements already in the subgraph, include in 
+  #     the subgraph the Extended Bounded Description for each object node, 
+  #     unless the object is in the ancestors list.
+  #
+  # The list of "ancestors" is empty by default. 
+  #
+  # This subgraph this process yields can be considered as a description of 
+  # the starting node.
+  #
+  # Compare to Concise Bounded Description 
+  # (https://www.w3.org/Submission/CBD/), the common subgraph scope used for 
+  # SPARQL DESCRIBE queries.
+  #
+  # @note this implementation requires that the `source_graph` remain unchanged 
+  #   while iterating over the description. The safest way to achive this is to 
+  #   use an immutable `RDF::Dataset` (e.g. a `Repository#snapshot`).
+  class ExtendedBoundedDescription
+    include RDF::Enumerable
+    include RDF::Queryable
+    
+    ##
+    # @!attribute ancestors [r]
+    #   @return Array<RDF::Term>
+    # @!attribute source_graph [r]
+    #   @return RDF::Queryable
+    # @!attribute starting_node [r]
+    #   @return RDF::Term
+    attr_reader  :ancestors, :source_graph, :starting_node
+
+    ##
+    # By analogy to Concise Bounded Description.
+    #
+    # @param source_graph  [RDF::Queryable]
+    # @param starting_node [RDF::Term]
+    # @param ancestors     [Array<RDF::Term>] default: []
+    def initialize(source_graph, starting_node, ancestors = [])
+      @source_graph  = source_graph
+      @starting_node = starting_node
+      @ancestors     = ancestors
+    end
+    
+    ##
+    # @see RDF::Enumerable#each
+    def each_statement
+      ancestors = @ancestors.dup
+
+      if block_given?
+        statements = source_graph.query(subject: starting_node).each
+        statements.each_statement { |st| yield st }
+        
+        ancestors << starting_node
+        
+        statements.each_object do |object|
+          next if object.literal?  || ancestors.include?(object)
+          ExtendedBoundedDescription
+            .new(source_graph, object, ancestors).each do |statement|
+            yield statement
+          end
+        end
+      end
+      enum_statement
+    end
+    alias_method :each, :each_statement
+  end
+end

data/lib/active_triples/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module ActiveTriples
-  VERSION = '0.10.2'.freeze
+  VERSION = '0.11.0'.freeze
 end

data/spec/active_triples/configurable_spec.rb

@@ -8,9 +8,7 @@ describe ActiveTriples::Configurable do
     end
   end
 
-  after do
-    Object.send(:remove_const, "DummyConfigurable")
-  end
+  after { Object.send(:remove_const, "DummyConfigurable") }
 
   it "should be okay if not configured" do
     expect(DummyConfigurable.type).to eq nil
@@ -21,9 +19,32 @@ describe ActiveTriples::Configurable do
     expect(DummyConfigurable.type).to eq []
   end
 
+  describe 'configuration inheritance' do
+    before do
+      DummyConfigurable.configure type: type,
+                                  base_uri: base_uri,
+                                  rdf_label: rdf_label,
+                                  repository: repository
+      class ConfigurableSubclass < DummyConfigurable; end
+    end
+
+    let(:type)       { RDF::Vocab::FOAF.Person }
+    let(:base_uri)   { 'http://example.org/moomin' }
+    let(:rdf_label)  { RDF::Vocab::DC.title }
+    let(:repository) { RDF::Repository.new }
+
+    after { Object.send(:remove_const, "ConfigurableSubclass") }
+
+    it 'inherits type from parent' do
+      expect(ConfigurableSubclass.type).to eq DummyConfigurable.type
+    end
+  end
+
   describe '#configure' do
     before do
-      DummyConfigurable.configure base_uri: "http://example.org/base", type: RDF::RDFS.Class, rdf_label: RDF::Vocab::DC.title
+      DummyConfigurable.configure base_uri:  "http://example.org/base",
+                                  type:      RDF::RDFS.Class,
+                                  rdf_label: RDF::Vocab::DC.title
     end
 
     it 'should set a base uri' do
@@ -31,8 +52,13 @@ describe ActiveTriples::Configurable do
     end
 
     it "should be able to set multiple types" do
-      DummyConfigurable.configure type: [RDF::RDFS.Container, RDF::RDFS.ContainerMembershipProperty]
-      expect(DummyConfigurable.type).to contain_exactly(RDF::RDFS.Class, RDF::RDFS.Container, RDF::RDFS.ContainerMembershipProperty)
+      DummyConfigurable.configure type: [RDF::RDFS.Container,
+                                         RDF::RDFS.ContainerMembershipProperty]
+
+      expect(DummyConfigurable.type)
+        .to contain_exactly(RDF::RDFS.Class,
+                            RDF::RDFS.Container,
+                            RDF::RDFS.ContainerMembershipProperty)
     end
 
     it 'should set an rdf_label' do
@@ -45,7 +71,9 @@ describe ActiveTriples::Configurable do
 
     it "should be able to set multiple types" do
       DummyConfigurable.configure type: RDF::RDFS.Container
-      expect(DummyConfigurable.type).to eq [RDF::RDFS.Class, RDF::RDFS.Container]
+
+      expect(DummyConfigurable.type)
+        .to eq [RDF::RDFS.Class, RDF::RDFS.Container]
     end
   end
 end

data/spec/active_triples/identifiable_spec.rb

@@ -58,12 +58,6 @@ describe ActiveTriples::Identifiable do
         attr_accessor :id
         configure base_uri: 'http://example.org/ns/'
 
-        def self.from_uri(uri, *args)
-          item = self.new
-          item.parent = args.first unless args.empty? or args.first.is_a?(Hash)
-          item
-        end
-
         def self.property(*args)
           prop = args.first
 
@@ -144,6 +138,16 @@ describe ActiveTriples::Identifiable do
       end
     end
 
+    describe '#parent=' do
+      before { class MyResource; include ActiveTriples::RDFSource; end }
+      let(:parent) { MyResource.new }
+
+      it 'sets parent' do
+        expect { subject.parent = parent }
+          .to change { subject.parent }.from(nil).to(parent)
+      end
+    end
+
     describe '#rdf_subject' do
       it 'has a subject' do
         expect(subject.rdf_subject).to eq 'http://example.org/ns/123'
@@ -164,6 +168,15 @@ describe ActiveTriples::Identifiable do
 
         expect(resource.relation).to eq [subject]
       end
+      it "can share that object with another resource" do
+        resource = MyResource.new
+        resource_2 = MyResource.new
+
+        resource.relation = subject
+        resource_2.relation = resource.relation
+
+        expect(resource.relation).to eq resource_2.relation
+      end
     end
   end
 end

data/spec/active_triples/list_spec.rb

@@ -230,7 +230,9 @@ END
       it "should have to_ary" do
         ary = list.to_ary
         expect(ary.size).to eq 4
-        expect(ary[1].elementValue).to eq ['Relations with Mexican Americans']
+
+        expect(ary[1].elementValue)
+          .to contain_exactly 'Relations with Mexican Americans'
       end
 
       it "should have size" do
@@ -243,12 +245,18 @@ END
           list[3].elementValue = ["1900s"]
           doc = Nokogiri::XML(subject.dump :rdfxml)
           ns = {rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#", mads: "http://www.loc.gov/mads/rdf/v1#"}
-          expect(doc.xpath('/rdf:RDF/mads:ComplexSubject/@rdf:about', ns).map(&:value)).to eq ["http://example.org/foo"]
-          expect(doc.xpath('//mads:ComplexSubject/mads:elementList/@rdf:parseType', ns).map(&:value)).to eq ["Collection"]
-          expect(doc.xpath('//mads:ComplexSubject/mads:elementList/*[position() = 1]/@rdf:about', ns).map(&:value)).to eq ["http://library.ucsd.edu/ark:/20775/bbXXXXXXX6"]
-          expect(doc.xpath('//mads:ComplexSubject/mads:elementList/*[position() = 2]/mads:elementValue', ns).map(&:text)).to eq ["Relations with Mexican Americans"]
-          expect(doc.xpath('//mads:ComplexSubject/mads:elementList/*[position() = 3]/@rdf:about', ns).map(&:value)).to eq ["http://library.ucsd.edu/ark:/20775/bbXXXXXXX4"]
-          expect(doc.xpath('//mads:ComplexSubject/mads:elementList/*[position() = 4]/mads:elementValue', ns).map(&:text)).to eq ["1900s"]
+          expect(doc.xpath('/rdf:RDF/mads:ComplexSubject/@rdf:about', ns).map(&:value))
+            .to contain_exactly "http://example.org/foo"
+          expect(doc.xpath('//mads:ComplexSubject/mads:elementList/@rdf:parseType', ns).map(&:value))
+            .to contain_exactly "Collection"
+          expect(doc.xpath('//mads:ComplexSubject/mads:elementList/*[position() = 1]/@rdf:about', ns).map(&:value))
+            .to contain_exactly "http://library.ucsd.edu/ark:/20775/bbXXXXXXX6"
+          expect(doc.xpath('//mads:ComplexSubject/mads:elementList/*[position() = 2]/mads:elementValue', ns).map(&:text))
+            .to contain_exactly "Relations with Mexican Americans"
+          expect(doc.xpath('//mads:ComplexSubject/mads:elementList/*[position() = 3]/@rdf:about', ns).map(&:value))
+            .to contain_exactly "http://library.ucsd.edu/ark:/20775/bbXXXXXXX4"
+          expect(doc.xpath('//mads:ComplexSubject/mads:elementList/*[position() = 4]/mads:elementValue', ns).map(&:text))
+            .to contain_exactly "1900s"
           expect(RDF::List.new(subject: list.rdf_subject, graph: subject)).to be_valid
         end
 

data/spec/active_triples/nested_attributes_spec.rb

@@ -177,24 +177,26 @@ describe "nesting attribute behavior" do
       context "for an existing B-nodes" do
         before do
           subject.attributes = { parts_attributes: [
-                                    {label: 'Alternator'},
-                                    {label: 'Distributor'},
-                                    {label: 'Transmission'},
-                                    {label: 'Fuel Filter'}]}
+                                   {label: 'Alternator'},
+                                   {label: 'Distributor'},
+                                   {label: 'Transmission'},
+                                   {label: 'Fuel Filter'}]}
           subject.parts_attributes = new_attributes
         end
 
         context "that allows destroy" do
-          let(:args) { [:parts, allow_destroy: true] }
+          let(:args)               { [:parts, allow_destroy: true] }
           let (:replace_object_id) { subject.parts[1].rdf_subject.to_s }
-          let (:remove_object_id) { subject.parts[3].rdf_subject.to_s }
+          let (:remove_object_id)  { subject.parts[3].rdf_subject.to_s }
 
-          let(:new_attributes) { [{ id: replace_object_id, label: "Universal Joint" },
-                                  { label:"Oil Pump" },
-                                  { id: remove_object_id, _destroy: '1', label: "bar1 uno" }] }
+          let(:new_attributes) do
+            [{ id: replace_object_id, label: "Universal Joint" },
+             { label:"Oil Pump" },
+             { id: remove_object_id, _destroy: '1', label: "bar1 uno" }]
+          end
 
           it "should update nested objects" do
-            expect(subject.parts.map{|p| p.label.first})
+            expect(subject.parts.map { |p| p.label.first })
               .to contain_exactly 'Universal Joint', 'Oil Pump', 
                                   an_instance_of(String), an_instance_of(String)
           end

data/spec/active_triples/persistable_spec.rb

@@ -10,10 +10,6 @@ describe ActiveTriples::Persistable do
     RDF::Statement(RDF::Node.new, RDF::Vocab::DC.title, 'Moomin')
   end
 
-  it 'raises an error with no #graph implementation' do
-    expect { subject << statement }.to raise_error(NameError, /graph/)
-  end
-
   describe 'method delegation' do
     context 'with a strategy' do
       let(:strategy_class) do

data/spec/active_triples/persistence_strategies/parent_strategy_spec.rb

@@ -6,11 +6,10 @@ describe ActiveTriples::ParentStrategy do
   let(:rdf_source) { BasicPersistable.new }
   
   shared_context 'with a parent' do
+    subject      { rdf_source.persistence_strategy }
     let(:parent) { BasicPersistable.new }
 
     before do
-      subject.parent = parent
-
       rdf_source.set_persistence_strategy(described_class)
       rdf_source.persistence_strategy.parent = parent
     end
@@ -54,8 +53,7 @@ describe ActiveTriples::ParentStrategy do
     
     let(:statements) do
       [RDF::Statement(subject.source.rdf_subject, RDF::Vocab::DC.title, 'moomin'),
-       RDF::Statement(:node, RDF::Vocab::DC.relation, subject.source.rdf_subject),
-       RDF::Statement(:node, RDF::Vocab::DC.relation, :other_node)]
+       RDF::Statement(subject.parent, RDF::Vocab::DC.relation, subject.source.rdf_subject)]
     end
 
     it 'removes graph from the parent' do
@@ -176,12 +174,61 @@ describe ActiveTriples::ParentStrategy do
     context 'with parent' do
       include_context 'with a parent'
 
-      it 'writes to #final_parent graph' do
-        rdf_source << [RDF::Node.new, RDF::Vocab::DC.title, 'moomin']
+      let(:parent_st) { RDF::Statement(parent,     RDF::URI(:p), rdf_source) }
+      let(:child_st)  { RDF::Statement(rdf_source, RDF::URI(:p), 'chld') }
+
+      it 'writes to #parent graph' do
+        rdf_source << child_st
+
+        expect { subject.persist! }
+          .to change { subject.parent.statements }
+               .to contain_exactly *rdf_source.statements
+      end
+
+      it 'writes to #parent graph when parent changes while child is live' do
+        parent.insert(parent_st)
+        parent.persist!
+
+        rdf_source.insert(child_st)
+
+        expect { subject.persist! }
+          .to change { parent.statements }
+               .from(contain_exactly(parent_st))
+               .to(contain_exactly(parent_st, child_st))
+      end
+
+      context 'with nested parents' do
+        let(:last) { BasicPersistable.new }
 
-        subject.persist!
-        expect(subject.final_parent.statements)
-          .to contain_exactly *rdf_source.statements
+        before do
+          parent.set_persistence_strategy(ActiveTriples::ParentStrategy)
+          parent.persistence_strategy.parent = last
+          rdf_source.reload
+        end
+        
+        it 'writes to #parent graph when parent changes while child is live' do
+          parent.insert(parent_st)
+          parent.persist!
+
+          rdf_source.insert(child_st)
+
+          expect { subject.persist! }
+            .to change { parent.statements }
+                 .from(contain_exactly(parent_st))
+                 .to(contain_exactly(parent_st, child_st))
+        end
+
+        it 'writes to #last graph when persisting' do
+          parent.insert(parent_st)
+          parent.persist!
+
+          rdf_source.insert(child_st)
+
+          expect { subject.persist!; parent.persist! }
+            .to change { last.statements }
+                 .from(contain_exactly(parent_st))
+                 .to(contain_exactly(parent_st, child_st))
+        end
       end
     end
   end
@@ -200,7 +247,7 @@ describe ActiveTriples::ParentStrategy::Ancestors do
 
     context 'with parents' do
       let(:parent) { BasicPersistable.new }
-      let(:last) { BasicPersistable.new }
+      let(:last)   { BasicPersistable.new }
       
       before do
         parent.set_persistence_strategy(ActiveTriples::ParentStrategy)