active-triples 0.7.6 → 0.8.0

data/lib/active_triples/relation.rb

@@ -42,7 +42,7 @@ module ActiveTriples
         .each_with_object([]) do |x, collector|
           converted_object = convert_object(x.object)
           collector << converted_object unless converted_object.nil?
-        end
+      end
     end
 
     def set(values)
@@ -52,14 +52,16 @@ module ActiveTriples
       values.each do |val|
         set_value(val)
       end
-      parent.persist! if parent.class.repository == :parent && parent.send(:repository)
+      parent.persist! if parent.persistence_strategy.is_a? ParentStrategy
     end
 
+    ##
+    # Deletes the values for this relation. This removes all triples matching
+    # the basic graph pattern [:rdf_subject :predicate ?object] from the parent
+    # Enumerable.
     def empty_property
       parent.query([rdf_subject, predicate, nil]).each_statement do |statement|
-        if !uri_class(statement.object) || uri_class(statement.object) == class_for_property
-          parent.delete(statement)
-        end
+        parent.delete(statement)
       end
     end
 
@@ -133,8 +135,9 @@ module ActiveTriples
           return
         end
         val = val.to_uri if val.respond_to? :to_uri
-        raise ValueError, val unless 
-          val.kind_of? RDF::Value or val.kind_of? RDF::Literal
+        raise "value must be an RDF URI, Node, Literal, or a valid datatype." \
+              " See RDF::Literal.\n\tYou provided #{val.inspect}" unless
+          val.kind_of? RDF::Term
         parent.insert [rdf_subject, predicate, val]
       end
 
@@ -144,9 +147,12 @@ module ActiveTriples
 
       def add_child_node(resource,object=nil)
         parent.insert [rdf_subject, predicate, resource.rdf_subject]
-        resource.parent = parent unless resource.frozen?
+        unless resource.frozen?
+          resource.set_persistence_strategy(ParentStrategy)
+          resource.parent = parent
+        end
         self.node_cache[resource.rdf_subject] = (object ? object : resource)
-        resource.persist! if resource.class.repository == :parent
+        resource.persist! if resource.persistence_strategy.is_a? ParentStrategy
       end
 
       def predicate
@@ -163,6 +169,8 @@ module ActiveTriples
       # Converts an object to the appropriate class.
       def convert_object(value)
         case value
+        when RDFSource
+          value
         when RDF::Literal
           return_literals? ? value : value.object
         when RDF::Resource
@@ -235,41 +243,5 @@ module ActiveTriples
           parent.rdf_subject
         end
       end
-
-    public
-
-    ##
-    # An error class for unallowable values in relations.
-    class ValueError < ArgumentError
-      # @!attribute [r] value
-      attr_reader :value
-
-      ##
-      # @param value [Object]
-      def initialize(value)
-        @value = value
-      end
-
-      ##
-      # @return [String]
-      def message
-        'value must be an RDF URI, Node, Literal, or a valid datatype. '\
-        "See RDF::Literal.\n\tYou provided #{value.inspect}"
-      end
-    end
-  end
-
-  class Term < Relation
-    def self.inherited(*)
-      warn 'ActiveTriples::Term is deprecated! ' \
-           'Use ActiveTriples::Relation instead.'
-      super
-    end
-
-    def initialize(*)
-      warn 'ActiveTriples::Term is deprecated! ' \
-           'Use ActiveTriples::Relation instead.'
-      super
-    end
   end
 end

data/lib/active_triples/repositories.rb

@@ -7,7 +7,9 @@ module ActiveTriples
   # RDF::Repository implementation to be used for persistence of
   # resources that will be shared between ActiveFedora::Base objects.
   #
-  #    ActiveTriples::Repositories.add_repository :blah, RDF::Repository.new
+  # @example registering a repository
+  #
+  #    ActiveTriples::Repositories.add_repository :defaulst, RDF::Repository.new
   #
   # Multiple repositories can be registered to keep different kinds of
   # resources seperate. This is configurable on subclasses of Resource
@@ -17,23 +19,32 @@ module ActiveTriples
   module Repositories
 
     ##
-    # @param name [Symbol] 
-    # @param repo [RDF::Repository] 
+    # Register a repository to be configured by name
+    #
+    # @param name [Symbol]
+    # @param repo [RDF::Repository]
     #
-    # @return [RDF::Repository]
-    # @raise [ArgumentError] if a non-repository is passed
+    # @return [RDF::Repository] gives the original repository on success
+    #
+    # @raise [RuntimeError] raised if the repository is not an `RDF::Repository`
     def add_repository(name, repo)
-      raise ArgumentError, "Repositories must be an RDF::Repository" unless 
-        repo.kind_of? RDF::Repository
+      raise "Repositories must be an RDF::Repository" unless repo.kind_of? RDF::Repository
       repositories[name] = repo
     end
     module_function :add_repository
 
+    ##
+    # Delete existing name, repository pairs from the registry hash
+    #
+    # @return [Hash<Symbol, Repository>] the now empty repository registry hash
     def clear_repositories!
       @repositories = {}
     end
     module_function :clear_repositories!
 
+    ##
+    # @return [Hash<Symbol, Repository>] a hash of currrently registered names 
+    #   and repositories
     def repositories
       @repositories ||= {}
     end
@@ -42,9 +53,13 @@ module ActiveTriples
     ##
     # Check for the specified rdf_subject in the specified repository
     # defaulting to search all registered repositories.
+    #
     # @param [String] rdf_subject
     # @param [Symbol] repository name
-    def has_subject?(rdf_subject,repo_name=nil)
+    # 
+    # @return [Boolean] true if the repository contains at least one statement 
+    #   with the given subject term
+    def has_subject?(rdf_subject, repo_name=nil)
       search_repositories = [repositories[repo_name]] if repo_name
       search_repositories ||= repositories.values
       found = false
@@ -55,6 +70,5 @@ module ActiveTriples
       found
     end
     module_function :has_subject?
-
   end
 end

data/lib/active_triples/version.rb

@@ -1,3 +1,3 @@
 module ActiveTriples
-  VERSION = '0.7.6'.freeze
+  VERSION = "0.8.0".freeze
 end

data/spec/active_triples/configurable_spec.rb

@@ -1,10 +1,12 @@
 require "spec_helper"
+
 describe ActiveTriples::Configurable do
   before do
     class DummyConfigurable
       extend ActiveTriples::Configurable
     end
   end
+
   after do
     Object.send(:remove_const, "DummyConfigurable")
   end
@@ -12,10 +14,12 @@ describe ActiveTriples::Configurable do
   it "should be okay if not configured" do
     expect(DummyConfigurable.type).to eq nil
   end
+
   it "should be okay if configured to nil" do
     DummyConfigurable.configure :type => nil
     expect(DummyConfigurable.type).to eq []
   end
+
   describe '#configure' do
     before do
       DummyConfigurable.configure base_uri: "http://example.org/base", type: RDF::RDFS.Class, rdf_label: RDF::DC.title
@@ -37,18 +41,10 @@ describe ActiveTriples::Configurable do
     it 'should set a type' do
       expect(DummyConfigurable.type).to eq [RDF::RDFS.Class]
     end
+
     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]
     end
   end
-
-  describe '#rdf_type' do
-    it "should set the type the old way" do
-      expect(DummyConfigurable).to receive(:configure).with(type: RDF::RDFS.Class).and_call_original
-      expect(Deprecation).to receive(:warn)
-      DummyConfigurable.rdf_type(RDF::RDFS.Class)
-      expect(DummyConfigurable.type).to eq [RDF::RDFS.Class]
-    end
-  end
 end

data/spec/active_triples/identifiable_spec.rb

@@ -3,24 +3,7 @@ require 'active_model'
 
 describe ActiveTriples::Identifiable do
   before do
-    class ActiveExample
-      include ActiveTriples::Identifiable
-
-      def self.property(*args)
-        prop = args.first
-
-        define_method prop.to_s do
-          resource.get_values(prop)
-        end
-
-        define_method "#{prop.to_s}=" do |*args|
-          resource.set_value(prop, *args)
-        end
-
-        resource_class.property(*args)
-      end
-
-    end
+    class ActiveExample; include ActiveTriples::Identifiable; end
   end
 
   after do

data/spec/active_triples/list_spec.rb

@@ -3,7 +3,6 @@ require 'nokogiri'
 require 'linkeddata'
 
 describe ActiveTriples::List do
-
   subject { ActiveTriples::List.new }
 
   context 'when empty' do
@@ -258,9 +257,6 @@ END
 
         it "should be a valid list" do
           list << "Val"
-          # TODO this is a workaround for https://github.com/projecthydra/active_fedora/issues/444
-          # remove the following line when #444 is closed.
-          list.resource.persist!
           expect(RDF::List.new(list.rdf_subject, subject)).to be_valid
         end
       end

data/spec/active_triples/persistable_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe ActiveTriples::Persistable do
+  subject { klass.new }
+
+  let(:klass) { Class.new { include ActiveTriples::Persistable } }
+
+  let(:statement) { RDF::Statement(RDF::Node.new, RDF::DC.title, 'Moomin') }
+
+  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
+        object_double(ActiveTriples::ParentStrategy).as_stubbed_const
+      end
+
+      let(:strategy) { instance_double('PersistenceStrategy') }
+
+      before do
+        allow(strategy_class).to receive(:new).and_return(strategy)
+        subject.set_persistence_strategy(strategy_class)
+      end
+
+      describe '#persist!' do
+        before { allow(subject).to receive(:run_callbacks).and_yield }
+
+        it 'sends message to strategy' do
+          expect(strategy).to receive(:persist!)
+          subject.persist!
+        end
+      end
+
+      describe '#destroy' do
+        it 'sends message to strategy' do
+          expect(strategy).to receive(:destroy)
+          subject.destroy
+        end
+      end
+
+      describe '#persisted?' do
+        it 'sends message to strategy' do
+          expect(strategy).to receive(:persisted?)
+          subject.persisted?
+        end
+      end
+
+      describe '#reload' do
+        it 'sends message to strategy' do
+          expect(strategy).to receive(:reload)
+          subject.reload
+        end
+      end
+    end
+  end
+
+  describe '#persistence_strategy' do
+    it 'defaults to RepositoryStrategy' do
+      expect(subject.persistence_strategy)
+        .to be_a ActiveTriples::RepositoryStrategy
+    end
+  end
+
+  describe '#set_persistence_strategy' do
+    let(:strategy_class) { double('strategy class') }
+    let(:strategy) { double('persistence strategy') }
+
+    before do
+      allow(strategy_class).to receive(:new).and_return(strategy)
+    end
+
+    it 'sets new persistence strategy as an instance of the given class' do
+      expect { subject.set_persistence_strategy(strategy_class) }
+        .to change { subject.persistence_strategy }
+             .from(an_instance_of(ActiveTriples::RepositoryStrategy))
+             .to(strategy)
+    end
+  end
+
+  context 'with graph implementation' do
+    before do
+      graph = RDF::Graph.new
+      allow(subject).to receive(:graph).and_return(graph)
+    end
+
+    it 'mirrors writes to graph' do
+      subject << statement
+      expect(subject.graph).to contain_exactly statement
+    end
+  end
+end

data/spec/active_triples/persistence_strategies/parent_strategy_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe ActiveTriples::ParentStrategy do
+  subject { described_class.new(rdf_source) }
+  let(:rdf_source) { BasicPersistable.new }
+
+  shared_context 'with a parent' do
+    before do
+      subject.parent = parent
+    end
+
+    let(:parent) { BasicPersistable.new }
+  end
+
+  context 'with a parent' do
+    include_context 'with a parent'
+    it_behaves_like 'a persistence strategy'
+  end
+
+  describe '#final_parent' do
+    it 'raises an error with no parent' do
+      expect { subject.final_parent }.to raise_error described_class::NilParentError
+    end
+
+    context 'with single parent' do
+      include_context 'with a parent'
+
+      it 'gives parent' do
+        expect(subject.final_parent).to eq subject.parent
+      end
+    end
+
+    context 'with parent chain' do
+      include_context 'with a parent'
+      let(:last) { double('last') }
+
+      it 'gives last parent terminating when no futher parents given' do
+        allow(parent).to receive(:parent).and_return(last)
+        expect(subject.final_parent).to eq last
+      end
+
+      it 'gives last parent terminating parent is nil' do
+        allow(parent).to receive(:parent).and_return(last)
+        allow(last).to receive(:parentt).and_return(nil)
+        expect(subject.final_parent).to eq last
+      end
+
+      it 'gives last parent terminating parent is same as current' do
+        allow(parent).to receive(:parent).and_return(last)
+        allow(last).to receive(:parentt).and_return(last)
+        expect(subject.final_parent).to eq last
+      end
+    end
+  end
+
+  describe '#parent' do
+    it { is_expected.to have_attributes(:parent => nil) }
+
+    it 'requires its parent to be RDF::Mutable' do
+      expect { subject.parent = Object.new }
+        .to raise_error described_class::UnmutableParentError
+    end
+
+    it 'requires its parent to be #mutable?' do
+      immutable = double
+      allow(immutable).to receive(:mutable?).and_return(false)
+      expect { subject.parent = immutable }
+        .to raise_error described_class::UnmutableParentError
+    end
+
+    context 'with a parent' do
+      include_context 'with a parent'
+      it { is_expected.to have_attributes(:parent => parent) }
+    end
+  end
+
+  describe '#persist!' do
+    it 'raises an error with no parent' do
+      expect { subject.persist! }.to raise_error described_class::NilParentError
+    end
+
+    context 'with parent' do
+      include_context 'with a parent'
+
+      it 'writes to #final_parent graph' do
+        rdf_source << RDF::Statement.new(RDF::Node.new, RDF::DC.title, 'moomin')
+        subject.persist!
+        expect(subject.final_parent.statements)
+          .to contain_exactly *rdf_source.statements
+      end
+    end
+  end
+end