rdf-ldp 0.9.2 → 0.9.3

data/lib/rdf/ldp/indirect_container.rb

@@ -87,9 +87,11 @@ module RDF::LDP
       predicate = inserted_content_relation
       return resource.to_uri if predicate == MEMBER_SUBJECT_URI
 
-      raise(NotAcceptable, "#{resource.to_uri} is an LDP-NR; cannot add " \
-                           'it to an IndirectContainer with a content '   \
-                           'relation.') if resource.non_rdf_source?
+      if resource.non_rdf_source?
+        raise(NotAcceptable, "#{resource.to_uri} is an LDP-NR; cannot add " \
+                             'it to an IndirectContainer with a content '   \
+                             'relation.')
+      end
 
       target = transaction || resource.graph
       statements = target.query([resource.subject_uri, predicate, :o])

data/lib/rdf/ldp/interaction_model.rb

@@ -1,14 +1,16 @@
 module RDF
   module LDP
+    ##
+    # Provides an interaction model registry.
     class InteractionModel
       class << self
         ##
         # Interaction models are in reverse order of preference for POST/PUT
-        # requests; e.g. if a client sends a request with Resource, RDFSource, and
-        # BasicContainer headers, the server gives a basic container.
+        # requests; e.g. if a client sends a request with Resource, RDFSource,
+        # oand BasicContainer headers, the server gives a basic container.
         #
-        # Interaction models are initialized in the correct order, but with no classed
-        # registered to handle them.
+        # Interaction models are initialized in the correct order, but with no
+        # class registered to handle them.
         @@interaction_models = {
           RDF::LDP::RDFSource.to_uri         => nil,
           RDF::LDP::Container.to_uri         => nil,
@@ -17,43 +19,47 @@ module RDF
           RDF::LDP::IndirectContainer.to_uri => nil,
           RDF::LDP::NonRDFSource.to_uri      => nil
         }
-        
+
         ##
-        # Register a new interaction model for one or more Link header URIs. klass.to_uri
-        # will automatically be registered.
+        # Register a new interaction model for one or more Link header URIs.
+        # klass.to_uri will automatically be registered.
         #
-        # @param [RDF::LDP::Resource] klass  the implementation class to register
+        # @param [RDF::LDP::Resource] klass  the implementation class to
+        #   register
         # @param [Hash <Symbol, *>] opts   registration options:
-        #   :default [true, false]  if true, klass will become the new default klass for
-        #     unrecognized Link headers
-        #   :for [RDF::URI, Array<RDF::URI>]  additional URIs for which klass should become 
-        #     the interaction model
+        #   :default [true, false]  if true, klass will become the new default
+        #     klass for unrecognized Link headers
+        #   :for [RDF::URI, Array<RDF::URI>]  additional URIs for which klass
+        #     should become the interaction model
         #
         # @return [RDF::LDP::Resource] klass
-        def register(klass, opts={})
+        def register(klass, opts = {})
           unless klass.ancestors.include?(RDF::LDP::Resource)
-            raise ArgumentError, "Interaction models must subclass `RDF::LDP::Resource`" 
+            raise ArgumentError,
+                  'Interaction models must subclass `RDF::LDP::Resource`'
           end
-          @@default = klass if opts[:default] or @@default.nil?
+          @@default = klass if opts[:default] || @@default.nil?
           @@interaction_models[klass.to_uri] = klass
           Array(opts[:for]).each do |model|
             @@interaction_models[model] = klass
           end
           klass
         end
-        
+
         ##
-        # Find the appropriate interaction model given a set of Link header URIs.
+        # Find the appropriate interaction model given a set of Link header
+        # URIs.
         #
         # @param [Array<RDF::URI>] uris
         #
-        # @return [Class] a subclass of {RDF::LDP::Resource} that most narrowly matches the
-        #   supplied `uris`, or the default interaction model if nothing matches
+        # @return [Class] a subclass of {RDF::LDP::Resource} that most narrowly
+        #   matches the supplied `uris`, or the default interaction model if
+        #   nothing matches
         def find(uris)
-          match = @@interaction_models.keys.reverse.find { |u| uris.include? u } 
+          match = @@interaction_models.keys.reverse.find { |u| uris.include? u }
           self.for(match) || @@default
         end
-        
+
         ##
         # Find the interaction model registered for a given uri
         #
@@ -63,23 +69,27 @@ module RDF
         def for(uri)
           @@interaction_models[uri]
         end
-        
+
         ##
         # The default registered interaction model
         def default
           @@default
         end
-        
+
         ##
-        # Test an array of URIs to see if their interaction models are compatible (e.g., all of the URIs
-        # refer either to RDF models or non-RDF models, but not a combination of both).
+        # Test an array of URIs to see if their interaction models are
+        # compatible (e.g., all of the URIs refer either to RDF models or
+        # non-RDF models, but not a combination of both).
         #
         # @param [Array<RDF::URI>] uris
-        # @return [TrueClass or FalseClass]  true if the models specified by `uris` are compatible
+        # @return [TrueClass or FalseClass]  true if the models specified by
+        #   `uris` are compatible
         def compatible?(uris)
-          classes = uris.collect { |m| self.for(m) }
-          (rdf,non_rdf) = classes.compact.partition { |c| c.ancestors.include?(RDFSource) }
-          rdf.empty? or non_rdf.empty?
+          classes        = uris.collect { |m| self.for(m) }
+          (rdf, non_rdf) =
+            classes.compact.partition { |c| c.ancestors.include?(RDFSource) }
+
+          rdf.empty? || non_rdf.empty?
         end
       end
     end

data/lib/rdf/ldp/non_rdf_source.rb

@@ -30,7 +30,9 @@ module RDF::LDP
     # @param [storage_adapter] a class implementing the StorageAdapter interface
     #
     # @see RDF::LDP::Resource#initialize
-    def initialize(subject_uri, data = RDF::Repository.new, storage_adapter = DEFAULT_ADAPTER)
+    def initialize(subject_uri,
+                   data            = RDF::Repository.new,
+                   storage_adapter = DEFAULT_ADAPTER)
       data ||= RDF::Repository.new # allows explict `nil` pass
       @storage = storage_adapter.new(self)
       super(subject_uri, data)
@@ -132,7 +134,7 @@ module RDF::LDP
     #
     # @raise [RDF::LDP::RequestError] when the request fails
     def to_response
-      (exists? && !destroyed?) ? storage.io : []
+      exists? && !destroyed? ? storage.io : []
     end
 
     private

data/lib/rdf/ldp/resource.rb

@@ -38,14 +38,15 @@ module RDF::LDP
   #   resource.exists? # => true
   #   resource.metagraph.dump :ttl
   #   # => "<http://example.org/moomin> a <http://www.w3.org/ns/ldp#Resource>;
-  #           <http://purl.org/dc/terms/modified> "2015-10-25T14:24:56-07:00"^^<http://www.w3.org/2001/XMLSchema#dateTime> ."
+  #   #       <http://purl.org/dc/terms/modified>
+  #   #         "2015-10-25T14:24:56-07:00"^^xsd:dateTime ."
   #
   # @example updating a Resource updates the `#last_modified` date
   #   resource.last_modified
-  #   # => #<DateTime: 2015-10-25T14:32:01-07:00 ((2457321j,77521s,571858283n),-25200s,2299161j)>
+  #   # => #<DateTime: 2015-10-25T14:32:01-07:00...>
   #   resource.update('blah', 'text/plain')
   #   resource.last_modified
-  #   # => #<DateTime: 2015-10-25T14:32:04-07:00 ((2457321j,77524s,330658065n),-25200s,2299161j)>
+  #   # => #<DateTime: 2015-10-25T14:32:04-07:00...>
   #
   # @example destroying a Resource
   #   resource.exists? # => true
@@ -75,8 +76,8 @@ module RDF::LDP
   #         #<RDF::LDP::Resource:0x00564f4a646028
   #           @data=#<RDF::Repository:0x2b27a5391708()>,
   #           @exists=true,
-  #           @metagraph=#<RDF::Graph:0x2b27a5322538(http://example.org/moomin#meta)>,
-  #           @subject_uri=#<RDF::URI:0x2b27a5322fec URI:http://example.org/moomin>>]
+  #           @metagraph=#<RDF::Graph:0xea7(http://example.org/moomin#meta)>,
+  #           @subject_uri=#<RDF::URI:0xea8 URI:http://example.org/moomin>>]
   #
   #   resource.request(:put, 200, {}, {}) # RDF::LDP::MethodNotAllowed: put
   #
@@ -161,7 +162,7 @@ module RDF::LDP
                     .map { |link| RDF::URI.intern(link.href) }
 
         return InteractionModel.default if models.empty?
-        
+
         raise NotAcceptable unless InteractionModel.compatible?(models)
 
         InteractionModel.find(models)
@@ -302,9 +303,9 @@ module RDF::LDP
     #
     # @return [String] an HTTP Etag
     #
-    # @note these etags are weak, but we allow clients to use them in 
+    # @note these etags are weak, but we allow clients to use them in
     #   `If-Match` headers, and use weak comparison. This is in conflict with
-    #   https://tools.ietf.org/html/rfc7232#section-3.1. See: 
+    #   https://tools.ietf.org/html/rfc7232#section-3.1. See:
     #   https://github.com/ruby-rdf/rdf-ldp/issues/68
     #
     # @see http://www.w3.org/TR/ldp#h-ldpr-gen-etags  LDP ETag clause for GET
@@ -558,24 +559,25 @@ module RDF::LDP
     ##
     # Sets the last modified date/time to now
     #
-    # @param transaction [RDF::Transaction] the transaction scope in which to 
+    # @param transaction [RDF::Transaction] the transaction scope in which to
     #   apply changes. If none (or `nil`) is given, the change is made outside
     #   any transaction scope.
     def set_last_modified(transaction = nil)
-      if transaction
-        # transactions do not support updates or pattern deletes, so we must
-        # ask the Repository for the current last_modified to delete the statement
-        # transactionally
+      return metagraph.update([subject_uri, MODIFIED_URI, DateTime.now]) unless
         transaction
-          .delete RDF::Statement(subject_uri, MODIFIED_URI, last_modified,
-                                 graph_name: metagraph_name) if last_modified
 
+      # transactions do not support updates or pattern deletes, so we must
+      # ask the Repository for the current last_modified to delete the
+      # statement transactionally
+      if last_modified
         transaction
-          .insert RDF::Statement(subject_uri, MODIFIED_URI, DateTime.now,
+          .delete RDF::Statement(subject_uri, MODIFIED_URI, last_modified,
                                  graph_name: metagraph_name)
-      else
-        metagraph.update([subject_uri, MODIFIED_URI, DateTime.now])
       end
+
+      transaction
+        .insert RDF::Statement(subject_uri, MODIFIED_URI, DateTime.now,
+                               graph_name: metagraph_name)
     end
 
     ##

data/lib/rdf/ldp/spec.rb

@@ -0,0 +1,6 @@
+require 'rdf/ldp/spec/resource'
+require 'rdf/ldp/spec/rdf_source'
+require 'rdf/ldp/spec/non_rdf_source'
+require 'rdf/ldp/spec/container'
+require 'rdf/ldp/spec/direct_container'
+require 'rdf/ldp/spec/indirect_container'

data/lib/rdf/ldp/spec/container.rb

@@ -0,0 +1,337 @@
+require 'rdf/ldp/spec/rdf_source'
+
+shared_examples 'a Container' do
+  it_behaves_like 'an RDFSource'
+
+  let(:uri) { RDF::URI('http://ex.org/moomin') }
+  subject { described_class.new(uri) }
+
+  it { is_expected.to be_container }
+
+  describe '#container_class' do
+    it 'returns a uri' do
+      expect(subject.container_class).to be_a RDF::URI
+    end
+  end
+
+  describe '#containment_triples' do
+    let(:resource) { RDF::URI('http://ex.org/mymble') }
+
+    it 'returns a uri' do
+      subject.add_containment_triple(resource)
+      expect(subject.containment_triples)
+        .to contain_exactly(an_instance_of(RDF::Statement))
+    end
+  end
+
+  describe '#add' do
+    let(:resource) { RDF::URI('http://ex.org/mymble') }
+    before { subject.create(StringIO.new, 'application/n-triples') }
+
+    it 'returns self' do
+      expect(subject.add(resource)).to eq subject
+    end
+
+    it 'containment triple is added to graph' do
+      expect(subject.add(resource).graph)
+        .to include subject.make_containment_triple(resource)
+    end
+  end
+
+  describe '#add_containment_triple' do
+    let(:resource) { RDF::URI('http://ex.org/mymble') }
+
+    it 'returns self' do
+      expect(subject.add_containment_triple(resource)).to eq subject
+    end
+
+    it 'containment triple is added to graph' do
+      expect(subject.add_containment_triple(resource).graph)
+        .to include subject.make_containment_triple(resource)
+    end
+  end
+
+  describe '#remove_containment_triple' do
+    before { subject.add_containment_triple(resource) }
+
+    let(:resource) { RDF::URI('http://ex.org/mymble') }
+
+    it 'returns self' do
+      expect(subject.remove_containment_triple(resource)).to eq subject
+    end
+
+    it 'membership triple is added to graph' do
+      expect(subject.remove_containment_triple(resource).graph)
+        .not_to include subject.make_containment_triple(resource)
+    end
+
+    it 'updates last_modified for container' do
+      expect { subject.remove_containment_triple(resource) }
+        .to change { subject.last_modified }
+    end
+
+    it 'updates etag for container' do
+      expect { subject.remove_containment_triple(resource) }
+        .to change { subject.etag }
+    end
+  end
+
+  describe '#make_containment_triple' do
+    let(:resource) { uri / 'papa' }
+
+    it 'returns a statement' do
+      expect(subject.make_containment_triple(resource)).to be_a RDF::Statement
+    end
+
+    it 'statement subject *or* object is #subject_uri' do
+      sub = subject.make_containment_triple(resource).subject
+      obj = subject.make_containment_triple(resource).object
+      expect([sub, obj]).to include subject.subject_uri
+    end
+
+    it 'converts Resource classes to URI' do
+      sub = subject.make_containment_triple(subject).subject
+      obj = subject.make_containment_triple(subject).object
+      expect([sub, obj]).to include subject.subject_uri
+    end
+  end
+
+  describe '#request' do
+    let(:graph) { RDF::Graph.new }
+
+    let(:env) do
+      { 'rack.input' => StringIO.new(graph.dump(:ntriples)),
+        'CONTENT_TYPE' => 'application/n-triples' }
+    end
+
+    let(:statement) do
+      RDF::Statement(subject.subject_uri,
+                     RDF::Vocab::LDP.contains,
+                     'moomin')
+    end
+
+    context 'with :PATCH',
+            if: described_class.private_method_defined?(:patch) do
+
+      it 'raises conflict error when editing containment triples' do
+        patch_statement = statement.clone
+        patch_statement.object = 'snorkmaiden'
+        patch = '@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .' \
+                "\n\nAdd { #{statement.subject.to_base} " \
+                "#{statement.predicate.to_base} #{statement.object.to_base} } ."
+        env = { 'CONTENT_TYPE' => 'text/ldpatch',
+                'rack.input'   => StringIO.new(patch) }
+
+        expect { subject.request(:patch, 200, {}, env) }
+          .to raise_error RDF::LDP::Conflict
+      end
+    end
+
+    context 'with :PUT',
+            if: described_class.private_method_defined?(:put) do
+      context 'when PUTing containment triples' do
+        it 'when creating a resource raises a Conflict error' do
+          graph << statement
+
+          expect { subject.request(:PUT, 200, { 'abc' => 'def' }, env) }
+            .to raise_error RDF::LDP::Conflict
+        end
+
+        it 'when resource exists raises a Conflict error' do
+          subject.create(StringIO.new, 'application/n-triples')
+          graph << statement
+          expect { subject.request(:PUT, 200, { 'abc' => 'def' }, env) }
+            .to raise_error RDF::LDP::Conflict
+        end
+
+        it 'can put existing containment triple' do
+          subject.create(StringIO.new, 'application/n-triples')
+          subject.graph << statement
+          graph << statement
+          expect(subject.request(:PUT, 200, { 'abc' => 'def' }, env).first)
+            .to eq 200
+        end
+
+        it 'writes data when putting existing containment triple' do
+          subject.create(StringIO.new, 'application/n-triples')
+          subject.graph << statement
+          graph << statement
+
+          new_st = RDF::Statement(RDF::URI('http://example.org/new_moomin'),
+                                  RDF::Vocab::DC.title,
+                                  'moomin')
+          graph << new_st
+          expect(subject.request(:PUT, 200, { 'abc' => 'def' }, env).last.graph)
+            .to have_statement new_st
+        end
+
+        it 'raises conflict error when without existing containment triples' do
+          subject.create(StringIO.new, 'application/n-triples')
+          subject.graph << statement
+          expect { subject.request(:PUT, 200, { 'abc' => 'def' }, env) }
+            .to raise_error RDF::LDP::Conflict
+        end
+      end
+    end
+
+    context 'when POST is implemented',
+            if: described_class.private_method_defined?(:post) do
+      let(:graph) { RDF::Graph.new }
+      before { subject.create(StringIO.new, 'application/n-triples') }
+
+      let(:env) do
+        { 'rack.input' => StringIO.new(graph.dump(:ntriples)),
+          'CONTENT_TYPE' => 'application/n-triples' }
+      end
+
+      it 'returns status 201' do
+        expect(subject.request(:POST, 200, {}, env).first).to eq 201
+      end
+
+      it 'gives created resource as body' do
+        expect(subject.request(:POST, 200, {}, env).last)
+          .to be_a RDF::LDP::Resource
+      end
+
+      it 'generates an id' do
+        expect(subject.request(:POST, 200, {}, env).last.subject_uri)
+          .to be_starts_with subject.subject_uri.to_s
+      end
+
+      it 'adds containment statement to resource' do
+        expect { subject.request(:POST, 200, {}, env) }
+          .to change { subject.containment_triples.count }.from(0).to(1)
+      end
+
+      it 'updates last_modified for container' do
+        expect { subject.request(:POST, 200, {}, env) }
+          .to change { subject.last_modified }
+      end
+
+      it 'updates etag for container' do
+        expect { subject.request(:POST, 200, {}, env) }
+          .to change { subject.etag }
+      end
+
+      context 'with Container interaction model' do
+        it 'creates a basic container' do
+          env['HTTP_LINK'] = "<#{RDF::LDP::Container.to_uri}>;rel=\"type\""
+          expect(subject.request(:POST, 200, {}, env).last)
+            .to be_a RDF::LDP::Container
+        end
+
+        context 'BasicContainer' do
+          it 'creates a basic container' do
+            env['HTTP_LINK'] =
+              '<http://www.w3.org/ns/ldp#BasicContainer>;rel="type"'
+            expect(subject.request(:POST, 200, {}, env).last)
+              .to be_a RDF::LDP::Container
+          end
+        end
+
+        context 'DirectContainer' do
+          it 'creates a direct container' do
+            env['HTTP_LINK'] =
+              "<#{RDF::LDP::DirectContainer.to_uri}>;rel=\"type\""
+
+            expect(subject.request(:POST, 200, {}, env).last)
+              .to be_a RDF::LDP::DirectContainer
+          end
+        end
+
+        context 'IndirectContainer' do
+          it 'creates a indirect container' do
+            env['HTTP_LINK'] =
+              "<#{RDF::LDP::IndirectContainer.to_uri}>;rel=\"type\""
+
+            expect(subject.request(:POST, 200, {}, env).last)
+              .to be_a RDF::LDP::IndirectContainer
+          end
+        end
+      end
+
+      context 'with a Slug' do
+        it 'creates resource with Slug' do
+          env['HTTP_SLUG'] = 'snork'
+          expect(subject.request(:POST, 200, {}, env).last.subject_uri)
+            .to eq subject.subject_uri / env['HTTP_SLUG']
+        end
+
+        it 'mints a uri when empty Slug is given' do
+          env['HTTP_SLUG'] = ''
+          expect(subject.request(:POST, 200, {}, env).last.subject_uri)
+            .to be_starts_with subject.subject_uri
+        end
+
+        it 'raises a 409 Conflict when slug is already taken' do
+          env['HTTP_SLUG'] = 'snork'
+          subject.request(:POST, 200, {}, env)
+
+          expect { subject.request(:POST, 200, {}, env) }
+            .to raise_error RDF::LDP::Conflict
+        end
+
+        it 'raises a 409 Conflict when slug is already taken but destroyed' do
+          env['HTTP_SLUG'] = 'snork'
+          created = subject.request(:POST, 200, {}, env).last
+          allow(created).to receive(:destroyed?).and_return true
+
+          expect { subject.request(:POST, 200, {}, env) }
+            .to raise_error RDF::LDP::Conflict
+        end
+
+        it 'raises a 406 NotAcceptable if slug has a uri fragment `#`' do
+          env['HTTP_SLUG'] = 'snork#maiden'
+
+          expect { subject.request(:POST, 200, {}, env) }
+            .to raise_error RDF::LDP::NotAcceptable
+        end
+
+        it 'url-encodes Slug' do
+          env['HTTP_SLUG'] = 'snork maiden'
+          expect(subject.request(:POST, 200, {}, env).last.subject_uri)
+            .to eq subject.subject_uri / 'snork%20maiden'
+        end
+      end
+
+      context 'with graph content' do
+        before do
+          graph << RDF::Statement(uri, RDF::Vocab::DC.title, 'moomin')
+          graph << RDF::Statement(RDF::Node.new, RDF::Vocab::DC.creator, 'tove')
+          graph <<
+            RDF::Statement(RDF::Node.new, RDF.type, RDF::Vocab::FOAF.Person)
+        end
+
+        it 'parses graph into created resource' do
+          expect(subject.request(:POST, 200, {}, env).last.to_response)
+            .to be_isomorphic_with graph
+        end
+
+        it 'adds a Location header' do
+          expect(subject.request(:POST, 200, {}, env)[1]['Location'])
+            .to start_with subject.subject_uri.to_s
+        end
+
+        context 'with quads' do
+          let(:graph) do
+            RDF::Graph.new(graph_name: subject.subject_uri,
+                           data: RDF::Repository.new)
+          end
+
+          let(:env) do
+            { 'rack.input' => StringIO.new(graph.dump(:nquads)),
+              'CONTENT_TYPE' => 'application/n-quads' }
+          end
+
+          it 'parses graph into created resource without regard for context' do
+            context_free_graph = RDF::Graph.new
+            context_free_graph << graph.statements
+
+            expect(subject.request(:POST, 200, {}, env).last.to_response)
+              .to be_isomorphic_with context_free_graph
+          end
+        end
+      end
+    end
+  end
+end