rdf-ldp 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eb5f41c7209feb6a7669bf5a39284adb6ec15339
-  data.tar.gz: 2e5fd941cad72b6a32f2724a57210db788d56c92
+  metadata.gz: 54ea7ba54f7ff921a5670547db56d81fcfc686ed
+  data.tar.gz: 3dfdbb9baa8e06b2e8ce34ef3c5f5c99f6af3a38
 SHA512:
-  metadata.gz: 147ea229c52f3c64eb2ba925b80b71fb3adb4bdbee938ad8df991b88e7356ed38e014866fd2e416ba209d26710a75b9ed6d55992f3c2a177111650bfa94e97a4
-  data.tar.gz: e1104014e6961b8a10ff2d6fcc7c76b7785fa0514975d372ba74a4d44dc5d1c547336ac4bc8b8633e710b5309136e6626e17d0aa6755700e621ecf28d97824c8
+  metadata.gz: 0df494fa4d14ffe6ccc5533bd042b567e9d5a166e35af5b4b759af9e738b486eac010f3eee40e5e2abdd3b0bcf6087f624b6b80756a575157498b5482a0e2d97
+  data.tar.gz: 8d69b716de23c7cf1a08d83e2b6620770d561c3aa4bfa43bf29a4024d74b60442c7fc19d58d4c8daf0b65e2d95502789d86fec192dad677b96c5576833c3ed51

data/README.md

@@ -53,8 +53,6 @@ Content-Length: 0
 Connection: Keep-Alive
 ```
 
-See 
-
 Rack::LDP
 ==========
 

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.4.0

data/app/lamprey.rb

@@ -0,0 +1,54 @@
+require 'rack/ldp'
+require 'sinatra/base'
+
+class RDF::Lamprey < Sinatra::Base
+
+  use Rack::LDP::ContentNegotiation
+  use Rack::LDP::Errors
+  use Rack::LDP::Responses
+  use Rack::ConditionalGet
+  use Rack::LDP::Requests
+  
+  # Set defaults in case user has not configured values
+  configure do
+    set :repository, RDF::Repository.new
+  end
+
+  get '/*' do
+    RDF::LDP::Container.new(RDF::URI(request.url), settings.repository)
+      .create('', 'text/turtle') if settings.repository.empty?    
+    RDF::LDP::Resource.find(RDF::URI(request.url), settings.repository)
+  end
+
+  patch '/*' do
+    RDF::LDP::Resource.find(RDF::URI(request.url), settings.repository)
+  end
+
+  post '/*' do
+    RDF::LDP::Resource.find(RDF::URI(request.url), settings.repository)
+  end
+
+  put '/*' do
+    begin
+      RDF::LDP::Resource.find(RDF::URI(request.url), settings.repository)
+    rescue RDF::LDP::NotFound
+      model = request.env.fetch('HTTP_LINK', '')
+      RDF::LDP::Resource.interaction_model(model)
+        .new(RDF::URI(request.url), settings.repository)
+    end
+  end
+
+  options '/*' do
+    RDF::LDP::Resource.find(RDF::URI(request.url), settings.repository)
+  end
+
+  head '/*' do
+    RDF::LDP::Resource.find(RDF::URI(request.url), settings.repository)
+  end
+
+  delete '/*' do
+    RDF::LDP::Resource.find(RDF::URI(request.url), settings.repository)
+  end
+
+  run! if app_file == $0
+end

data/bin/lamprey

@@ -2,8 +2,4 @@
 $:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'app')))
 require 'lamprey'
 
-begin
-  require 'rdf/sparql'
-rescue LoadError => e; end
-
 RDF::Lamprey.run!

data/lib/rack/ldp.rb

@@ -1,7 +1,7 @@
 require 'rack'
 begin
   require 'linkeddata'
-rescue LoadError => e
+rescue LoadError
   require 'rdf/turtle'
   require 'json/ld'
 end
@@ -11,7 +11,7 @@ require 'rdf/ldp'
 
 module Rack
   ##
-  # Provides Rack middleware for handling Linked Data Platform  requirements
+  # Provides Rack middleware for handling Linked Data Platform requirements
   # when passed {RDF::LDP::Resource} and its subclasses as response objects.
   #
   # Response objects that are not an {RDF::LDP::Resource} are passed over 
@@ -20,16 +20,17 @@ module Rack
   #
   # The suite can be mix-and-matched as needed. This allows easy swap in of 
   # custom handlers for parts of the behavior. It is recommended that you use
-  # {Rack::LDP::ContentNegotiation}, {Rack::LDP::Errors}, and 
-  # {Rack::LDP::Responses} as the outer three services. With these in place,
-  # you can handle requests as needed in your application, giving responses
-  # conforming to the core {RDF::LDP::Resource} interface.
+  # {Rack::LDP::ContentNegotiation}, {Rack::LDP::Errors}, {Rack::LDP::Responses}
+  # and {Rack::LDP::Reousets} as the outer middleware layers. With these in 
+  # place, you can handle requests as needed in your application, giving 
+  # responses conforming to the core {RDF::LDP::Resource} interface.
   #
   # @example
   #   run Rack:;Builder.new do
   #     use Rack::LDP::ContentNegotiation
   #     use Rack::LDP::Errors
   #     use Rack::LDP::Responses
+  #     use Rack::LDP::Requests
   #     # ...
   #   end
   # 
@@ -110,10 +111,29 @@ module Rack
 
     ##
     # Specializes {Rack::LinkedData::ContentNegotiation}, making the default 
-    # return type 'text/turtle'
+    # return type 'text/turtle'.
+    #
+    # @see Rack::LinkedData::ContentNegotiation}, making
     class ContentNegotiation < Rack::LinkedData::ContentNegotiation
+      DEFAULT_PREFIXES = 
+        Hash[*RDF::Vocabulary.map { |v| [v.__prefix__, v.to_uri] }.flatten]
+        .freeze
+
       def initialize(app, options = {})
         options[:default] ||= 'text/turtle'
+        options[:prefixes] ||= DEFAULT_PREFIXES.dup
+        super
+      end
+
+      ##
+      # The default LinkedData Conneg doesn't support wildcard operators. We 
+      # patch in support for 'text/*' manually, giving Turtle. This should be 
+      # considered helpful by LDP clients.
+      # 
+      # @see Rack::LinkedData::ContentNegotiation#find_writer_for_content_type
+      def find_writer_for_content_type(content_type)
+        return [RDF::Writer.for(:ttl), 'text/turtle'] if 
+          content_type == 'text/*'
         super
       end
     end

data/lib/rdf/ldp/container.rb

@@ -34,35 +34,63 @@ module RDF::LDP
     end
 
     ##
+    # Create with validation as required for the LDP container.
+    #
+    # @raise [RDF::LDP::Conflict] if the create inserts triples that are not 
+    #   allowed by LDP for the container type
     # @see RDFSource#create
-    def create(input, content_type)
-      super { |statements| validate_triples!(statements) }
+    def create(input, content_type, &block)
+      super do |transaction| 
+        validate_triples!(transaction)
+        yield transaction if block_given?
+      end
+      self
     end
     
     ##
+    # Updates with validation as required for the LDP container.
+    #
+    # @raise [RDF::LDP::Conflict] if the update edits triples that are not 
+    #   allowed by LDP for the container type
     # @see RDFSource#update
-    def update(input, content_type)
-      super { |statements| validate_triples!(statements) }
+    def update(input, content_type, &block)
+      super do |transaction| 
+        validate_triples!(transaction)
+        yield transaction if block_given?
+      end
+      self
     end
 
     ##
     # Adds a member `resource` to the container. Handles containment and 
     # membership triples as appropriate for the container type.
     #
+    # If a transaction is passed as the second argument, the additon of the 
+    # containment triple is completed when the transaction closes; otherwise it is 
+    # handled atomically.
+    #
     # @param [RDF::Term] a new member for this container
+    # @param transaction [RDF::Transaction] an active transaction as context for
+    #   the addition
     # @return [Container] self
-    def add(resource)
-      add_containment_triple(resource.to_uri)
+    def add(resource, transaction = nil)
+      add_containment_triple(resource.to_uri, transaction)
     end
 
     ##
     # Removes a member `resource` from the container. Handles containment and
     # membership triples as appropriate for the container type.
     #
+    # If a transaction is passed as the second argument, the removal of the 
+    # containment triple is completed when the transaction closes; otherwise it is 
+    # handled atomically.
+    #
     # @param [RDF::Term] a new member for this container
+    # @param transaction [RDF::Transaction] an active transaction as context for
+    #   the removal
     # @return [Container] self
-    def remove(resource)
-      remove_containment_triple(resource.to_uri)
+    def remove(resource, transaction = nil)
+      remove_containment_triple(resource.to_uri, transaction)
     end
 
     ##
@@ -77,39 +105,50 @@ module RDF::LDP
     # @param [RDF::Statement] statement
     #
     # @return [Boolean] true if the containment triple exists
-    #
-    # @todo for some reason `#include?` doesn't work! figure out why, this is 
-    #   clumsy.
     def has_containment_triple?(statement)
-      !(containment_triples.select { |t| statement == t }.empty?)
+      !(containment_triples.find { |t| statement == t }.nil?)
     end
 
     ##
     # Adds a containment triple for `resource` to the container's `#graph`.
     #
-    # @param [RDF::Term] a new member for this container
+    # If a transaction is passed as the second argument, the triple is added to
+    # the transaction's inserts; otherwise it is added directly to `#graph`.
+    #
+    # @param resource [RDF::Term] a new member for this container
+    # @param transaction [RDF::Transaction] 
     # @return [Container] self
-    def add_containment_triple(resource)
-      graph << make_containment_triple(resource)
+    def add_containment_triple(resource, transaction = nil)
+      target = transaction || graph
+      target << make_containment_triple(resource)
+      set_last_modified(transaction)
       self
     end
 
     ##
     # Remove a containment triple for `resource` to the container's `#graph`.
     #
-    # @param [RDF::Term] a member to remove from this container
+    # If a transaction is passed as the second argument, the triple is added to
+    # the transaction's deletes; otherwise it is deleted directly from `#graph`.
+    #
+    # @param resource [RDF::Term] a member to remove from this container
+    # @param transaction [RDF::Transaction] 
     # @return [Container] self
-    def remove_containment_triple(resource)
-      graph.delete(make_containment_triple(resource))
+    def remove_containment_triple(resource, transaction = nil)
+      target = transaction || graph
+      target.delete(make_containment_triple(resource))
+      set_last_modified(transaction)
       self
     end
 
     ##
-    # @param [RDF::Term] a member for this container
+    # @param [RDF::Term] a member to be represented in the containment triple
     #
-    # @return [RDF::URI] the containment triple
+    # @return [RDF::URI] the containment triple, with a graph_name pointing 
+    #   to `#graph`
     def make_containment_triple(resource)
-      RDF::Statement(subject_uri, RDF::Vocab::LDP.contains, resource)
+      RDF::Statement(subject_uri, RDF::Vocab::LDP.contains, resource, 
+                     graph_name: subject_uri)
     end
 
     private
@@ -123,10 +162,11 @@ module RDF::LDP
       temp_graph = RDF::Graph.new << graph.statements
       send(method, env['rack.input'], temp_graph)
 
-      validate_triples!(temp_graph)
+      validate_statements!(temp_graph)
       graph.clear!
       graph << temp_graph.statements
 
+      set_last_modified
       [200, update_headers(headers), self]
     end
 
@@ -149,14 +189,45 @@ module RDF::LDP
       id = (subject_uri / slug).canonicalize
 
       created = klass.new(id, @data)
-                .create(env['rack.input'], env['CONTENT_TYPE'])
+                          
+      created.create(env['rack.input'], env['CONTENT_TYPE']) do |transaction|
+        add(created, transaction)
+      end
       
-      add(created)
       headers['Location'] = created.subject_uri.to_s
       [201, created.send(:update_headers, headers), created]
     end
 
-    def validate_triples!(statements)
+    def validate_triples!(transaction)
+      existing_triples = containment_triples.to_a
+      
+      inserts = transaction.inserts.select do |st|
+        st.subject == subject_uri && st.predicate == RDF::Vocab::LDP.contains
+      end
+
+      inserts.each do |statement|
+        existing_triples.delete(statement) do 
+          raise Conflict.new('Attempted to write unacceptable LDP ' \
+                             "containment-triple: #{statement}") 
+        end
+      end
+
+      deletes = transaction.deletes.select do |st| 
+        st.subject == subject_uri && 
+          predicate == RDF::Vocab::LDP.contains && 
+          !inserts.include?(st)
+      end
+      
+      deletes = deletes + existing_triples
+      
+      raise Conflict.new('Cannot remove containment triples in updates. ' \
+                         "Attepted to remove #{deletes}") unless
+        deletes.empty?
+    end
+
+    ##
+    # supports Patch.
+    def validate_statements!(statements)
       existing_triples = containment_triples.to_a
       statements.query(subject: subject_uri, 
                        predicate: RDF::Vocab::LDP.contains) do |statement|

data/lib/rdf/ldp/direct_container.rb

@@ -36,11 +36,14 @@ module RDF::LDP
     # membership triple to the memebership resource.
     #
     # @see RDF::LDP::Container#add
-    def add(resource)
-      process_membership_resource(resource) do |membership, triple|
-        super
-        membership.graph << triple
+    def add(resource, transaction = nil)
+      target = transaction || graph
+      process_membership_resource(resource) do |membership, quad, resource|
+        super(resource, transaction)
+        target = transaction || membership.graph
+        target << quad
       end
+      self
     end
 
     ##
@@ -48,11 +51,13 @@ module RDF::LDP
     # removes membership triple to the memebership resource.
     #
     # @see RDF::LDP::Container#remove
-    def remove(resource)
-      process_membership_resource(resource) do |membership, triple|
-        super
-        membership.graph.delete(triple)
+    def remove(resource, transaction = nil)
+      process_membership_resource(resource) do |membership, quad, resource|
+        super(resource, transaction)
+        target = transaction || membership.graph
+        target.delete(quad)
       end
+      self
     end
 
     ##
@@ -142,7 +147,7 @@ module RDF::LDP
     end
 
     def process_membership_resource(resource, &block)
-      triple = make_membership_triple(resource.to_uri)
+      statement = make_membership_triple(resource.to_uri)
 
       begin
         membership_rs = membership_resource
@@ -151,9 +156,8 @@ module RDF::LDP
                                 "#{membership_constant_uri} does not exist")
       end
 
-      yield(membership_resource, triple, resource) if block_given?
-
-      self
+      statement.graph_name = membership_rs.subject_uri
+      yield(membership_rs, statement, resource) if block_given?
     end
   end
 end

data/lib/rdf/ldp/non_rdf_source.rb

@@ -17,7 +17,7 @@ module RDF::LDP
   #   a definition of NonRDFSource in LDP
   class NonRDFSource < Resource
     # Use DC elements format
-    FORMAT_TERM = RDF::DC11.format
+    FORMAT_TERM = RDF::Vocab::DC11.format
     DESCRIBED_BY_TERM = RDF::URI('http://www.w3.org/2007/05/powder-s#describedby')
     
     ##
@@ -50,7 +50,7 @@ module RDF::LDP
       storage.io { |io| IO.copy_stream(input.binmode, io) }
       super
       self.content_type = c_type
-      RDFSource.new(description_uri, @data).create('', 'text/plain')
+      RDFSource.new(description_uri, @data).create('', 'application/n-triples')
       self
     end
 
@@ -58,6 +58,7 @@ module RDF::LDP
     # @see RDF::LDP::Resource#update
     def update(input, c_type)
       storage.io { |io| IO.copy_stream(input.binmode, io) }
+      super
       self.content_type = c_type
       self
     end
@@ -72,10 +73,6 @@ module RDF::LDP
       super
     end
 
-    def etag
-      "#{Digest::SHA1.base64digest(storage.io.read)}"
-    end
-
     ##
     # @raise [RDF::LDP::NotFound] if the describedby resource doesn't exist
     #

data/lib/rdf/ldp/rdf_source.rb

@@ -9,25 +9,26 @@ module RDF::LDP
   #   - a `#graph` representing the "entire persistent state"
   #   - a `#metagraph` containing internal properties of the RDFSource
   #
-  # Persistence schemes must be able to reconstruct both `#graph` and 
-  # `#metagraph` accurately and separately (e.g. by saving them as distinct
-  # named graphs). Statements in `#metagraph` are considered canonical for the
-  # purposes of server-side operations; in the `RDF::LDP` core, this means they
-  # determine interaction model.
+  # Repository implementations must be able to reconstruct both `#graph` and 
+  # `#metagraph` accurately and separately (e.g., by saving them as distinct
+  # named graphs).
+  # 
+  # The implementations of `#create` and `#update` in `RDF::LDP::Resource` are 
+  # overloaded to handle the edits to `#graph` within the same transaction as 
+  # the base `#metagraph` updates. `#to_response` is overloaded to return an 
+  # unnamed `RDF::Graph`, to be transformed into an HTTP Body by
+  # `Rack::LDP::ContentNegotiation`.
   #
-  # Note that the contents of `#metagraph`'s are *not* the same as 
-  # LDP-server-managed triples. `#metagraph` contains statements internal 
-  # properties of the RDFSource which are necessary for the server's management
-  # purposes, but MAY be absent from the representation of its state in `#graph`.
+  # @note the contents of `#metagraph`'s are *not* the same as 
+  # LDP-server-managed triples. `#metagraph` contains internal properties of the
+  # RDFSource which are necessary for the server's management purposes, but MAY
+  # be absent from (or in conflict with) the representation of its state in 
+  # `#graph`.
   # 
   # @see http://www.w3.org/TR/ldp/#dfn-linked-data-platform-rdf-source definition 
   #   of ldp:RDFSource in the LDP specification
   class RDFSource < Resource
 
-    # @!attribute [rw] graph
-    #   a graph representing the current persistent state of the resource.
-    attr_accessor :graph
-
     class << self
       ##
       # @return [RDF::URI] uri with lexical representation 
@@ -42,22 +43,50 @@ module RDF::LDP
     ##
     # @see RDF::LDP::Resource#initialize
     def initialize(subject_uri, data = RDF::Repository.new)
-      @graph = RDF::Graph.new(subject_uri, data: data)
+      @subject_uri = subject_uri
+      @data = data
       super
       self
     end
 
+    ##
+    # @return [RDF::Graph] a graph representing the current persistent state of 
+    #   the resource.
+    def graph
+      @graph ||= RDF::Graph.new(@subject_uri, data: @data)
+    end
+
     ##
     # Creates the RDFSource, populating its graph from the input given
     #
+    # @example
+    #   repository = RDF::Repository.new
+    #   ldprs = RDF::LDP::RDFSource.new('http://example.org/moomin', repository)
+    #   ldprs.create('<http://ex.org/1> <http://ex.org/prop> "moomin" .', 'text/turtle')
+    #
     # @param [IO, File, #to_s] input  input (usually from a Rack env's 
     #   `rack.input` key) used to determine the Resource's initial state.
     # @param [#to_s] content_type  a MIME content_type used to read the graph.
     #
-    # @yield gives the new contents of `graph` to the caller's block before 
-    #   altering the state of the resource. This is useful when validation is
-    #   required or triples are to be added by a subclass.
-    # @yieldparam [RDF::Enumerable] the contents parsed from input.
+    # @yield gives an in-progress transaction (changeset) to collect changes to 
+    #   graph, metagraph and other resources' (e.g. containers) graphs. 
+    # @yieldparam tx [RDF::Transaction] a transaction targeting `#graph` as the 
+    #   default graph name
+    #
+    # @example altering changes before execution with block syntax
+    #   content = '<http://ex.org/1> <http://ex.org/prop> "moomin" .'
+    #
+    #   ldprs.create(content, 'text/turtle') do |tx|
+    #     tx.insert([RDF::URI('s'), RDF::URI('p'), 'custom'])
+    #     tx.insert([RDF::URI('s'), RDF::URI('p'), 'custom', RDF::URI('g')])
+    #   end
+    #
+    # @example validating changes before execution with block syntax
+    #   content = '<http://ex.org/1> <http://ex.org/prop> "moomin" .'
+    #
+    #   ldprs.create(content, 'text/turtle') do |tx|
+    #     raise "cannot delete triples on create!" unless tx.deletes.empty?
+    #   end
     #
     # @raise [RDF::LDP::RequestError] 
     # @raise [RDF::LDP::UnsupportedMediaType] if no reader can be found for the 
@@ -68,11 +97,12 @@ module RDF::LDP
     #
     # @return [RDF::LDP::Resource] self
     def create(input, content_type, &block)
-      super
-      statements = parse_graph(input, content_type)
-      yield statements if block_given?
-      graph << statements
-      self
+      super do |transaction|
+        transaction.graph_name = subject_uri
+        statements = parse_graph(input, content_type)
+        transaction << statements
+        yield transaction if block_given?
+      end
     end
 
     ##
@@ -84,10 +114,18 @@ module RDF::LDP
     # @param [#to_s] content_type  a MIME content_type used to interpret the
     #   input.
     #
-    # @yield gives the new contents of `graph` to the caller's block before 
-    #   altering the state of the resource. This is useful when validation is
-    #   required or triples are to be added by a subclass.
-    # @yieldparam [RDF::Enumerable] the triples parsed from input.
+    # @yield gives an in-progress transaction (changeset) to collect changes to 
+    #   graph, metagraph and other resources' (e.g. containers) graphs. 
+    # @yieldparam tx [RDF::Transaction] a transaction targeting `#graph` as the 
+    #   default graph name
+    #
+    # @example altering changes before execution with block syntax
+    #   content = '<http://ex.org/1> <http://ex.org/prop> "moomin" .'
+    #
+    #   ldprs.update(content, 'text/turtle') do |tx|
+    #     tx.insert([RDF::URI('s'), RDF::URI('p'), 'custom'])
+    #     tx.insert([RDF::URI('s'), RDF::URI('p'), 'custom', RDF::URI('g')])
+    #   end
     #
     # @raise [RDF::LDP::RequestError] 
     # @raise [RDF::LDP::UnsupportedMediaType] if no reader can be found for the 
@@ -95,11 +133,13 @@ module RDF::LDP
     #
     # @return [RDF::LDP::Resource] self
     def update(input, content_type, &block)
-      return create(input, content_type) unless exists?
-      statements = parse_graph(input, content_type)
-      yield statements if block_given?
-      graph.clear!
-      graph << statements
+      super do |transaction|
+        transaction.graph_name = subject_uri
+        transaction << parse_graph(input, content_type)
+        yield transaction if block_given?
+        graph.clear
+      end
+
       self
     end
 
@@ -107,42 +147,12 @@ module RDF::LDP
     # Clears the graph and marks as destroyed.
     #
     # @see RDF::LDP::Resource#destroy
-    def destroy
-      @graph.clear
-      super
-    end
-
-    ##
-    # Returns an Etag. This may be a strong or a weak ETag.
-    #
-    # @return [String] an HTTP Etag 
-    #
-    # @note the current implementation is a naive one that combines a couple of 
-    # blunt heurisitics. 
-    # 
-    # @todo add an efficient hash function for RDF Graphs to RDF.rb and use that
-    #   here?
-    #
-    # @see http://ceur-ws.org/Vol-1259/proceedings.pdf#page=65 for a recent
-    #   treatment of digests for RDF graphs
-    #
-    # @see http://www.w3.org/TR/ldp#h-ldpr-gen-etags  LDP ETag clause for GET
-    # @see http://www.w3.org/TR/ldp#h-ldpr-put-precond  LDP ETag clause for PUT
-    # @see http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.3.3 
-    #   description of strong vs. weak validators
-    def etag
-      subs = graph.subjects.map { |s| s.node? ? nil : s.to_s }
-             .compact.sort.join()
-      "\"#{Digest::SHA1.base64digest(subs)}#{graph.statements.count}\""
+    def destroy(&block)
+      super do |_|
+        graph.clear
+      end
     end
 
-    ##
-    # @param [String] tag  a tag to compare to `#etag`
-    # @return [Boolean] whether the given tag matches `#etag`
-    # def match?(tag)
-    #   return false unless tag.split('==').last == graph.statements.count.to_s
-    # end
-
     ##
     # @return [Boolean] whether this is an ldp:RDFSource
     def rdf_source?
@@ -161,6 +171,8 @@ module RDF::LDP
     ##
     # Process & generate response for PUT requsets.
     #
+    # @note patch is currently not transactional.
+    #
     # @raise [RDF::LDP::UnsupportedMediaType] when a media type other than 
     #   LDPatch is used
     # @raise [RDF::LDP::BadRequest] when an invalid document is given
@@ -171,6 +183,7 @@ module RDF::LDP
       raise UnsupportedMediaType unless method
 
       send(method, env['rack.input'], graph)
+      set_last_modified
       [200, update_headers(headers), self]
     end
    
@@ -182,20 +195,16 @@ module RDF::LDP
         'application/sparql-update' => :sparql_update }
     end
    
-    def ld_patch(input, graph)
-      begin
-        LD::Patch.parse(input).execute(graph)
-      rescue LD::Patch::Error => e
-        raise BadRequest, e.message
-      end
+    def ld_patch(input, graph, &block)
+      LD::Patch.parse(input).execute(graph)
+    rescue LD::Patch::Error => e
+      raise BadRequest, e.message
     end
 
     def sparql_update(input, graph)
-      begin
-        SPARQL.execute(input, graph, update: true)
-      rescue SPARQL::MalformedQuery => e
-        raise BadRequest, e.message
-      end
+      SPARQL.execute(input, graph, update: true)
+    rescue SPARQL::MalformedQuery => e
+      raise BadRequest, e.message
     end
 
     ##
@@ -221,7 +230,6 @@ module RDF::LDP
         env.has_key?('HTTP_IF_MATCH') && !match?(env['HTTP_IF_MATCH'])
     end
 
-
     ##
     # Finds an {RDF::Reader} appropriate for the given content_type and attempts
     # to parse the graph string.
@@ -244,7 +252,7 @@ module RDF::LDP
       raise(RDF::LDP::UnsupportedMediaType, content_type) if reader.nil?
       input = input.read if input.respond_to? :read
       begin
-        RDF::Graph.new << reader.new(input, base_uri: subject_uri)
+        RDF::Graph.new << reader.new(input, base_uri: subject_uri, validate: true)
       rescue RDF::ReaderError => e
         raise RDF::LDP::BadRequest, e.message
       end  

data/lib/rdf/ldp/resource.rb

@@ -19,14 +19,15 @@ module RDF::LDP
   # from, and may conflict with, other RDF and non-RDF information about the 
   # resource (e.g. representations suitable for a response body). Metagraph 
   # contains a canonical `rdf:type` statement, which specifies the resource's 
-  # interaction model. If the resource is deleted, a flag in metagraph 
-  # indicates this.
+  # interaction model and a (dcterms:modified) last-modified date. If the 
+  # resource is deleted, a (prov:invalidatedAt) flag in metagraph indicates 
+  # this.
   # 
   # The contents of `#metagraph` should not be confused with LDP 
   # server-managed-triples, Those triples are included in the state of the 
   # resource as represented by the response body. `#metagraph` is invisible to
   # the client except where a subclass mirrors its contents in the body.
-  #
+  # 
   # @example creating a new Resource
   #   repository = RDF::Repository.new
   #   resource = RDF::LDP::Resource.new('http://example.org/moomin', repository)
@@ -36,14 +37,55 @@ module RDF::LDP
   #
   #   resource.exists? # => true
   #   resource.metagraph.dump :ttl
-  #   # => "<http://example.org/moomin> a <http://www.w3.org/ns/ldp#Resource> ."
+  #   # => "<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> ."
+  #
+  # @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)>
+  #   resource.update('blah', 'text/plain')
+  #   resource.last_modified
+  #   # => #<DateTime: 2015-10-25T14:32:04-07:00 ((2457321j,77524s,330658065n),-25200s,2299161j)>
+  #   
+  # @example destroying a Resource
+  #   resource.exists? # => true
+  #   resource.destroyed? # => false
+  #
+  #   resource.destroy
+  #
+  #   resource.exists? # => true
+  #   resource.destroyed? # => true
+  #
+  # Rack (via `RDF::LDP::Rack`) uses the `#request` method to dispatch requests and
+  # interpret responses. Disallowed HTTP methods result in 
+  # `RDF::LDP::MethodNotAllowed`. Individual Resources populate `Link`, `Allow`, 
+  # `ETag`, `Last-Modified`, and `Accept-*` headers as required by LDP. All 
+  # subclasses (MUST) return `self` as the Body, and respond to `#each`/
+  # `#respond_to` with the intended body.
+  #
+  # @example using HTTP request methods to get a Rack response 
+  #   resource.request(:get, 200, {}, {})
+  #   # => [200,
+  #         {"Link"=>"<http://www.w3.org/ns/ldp#Resource>;rel=\"type\"",
+  #          "Allow"=>"GET, DELETE, OPTIONS, HEAD",
+  #          "Accept-Post"=>"",
+  #          "Accept-Patch"=>"",
+  #          "ETag"=>"W/\"2015-10-25T21:39:13.111500405+00:00\"",
+  #          "Last-Modified"=>"Sun, 25 Oct 2015 21:39:13 GMT"},
+  #         #<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>>]
+  #
+  #   resource.request(:put, 200, {}, {}) # RDF::LDP::MethodNotAllowed: put
   #
   # @see http://www.w3.org/TR/ldp/ for the Linked Data platform specification
   # @see http://www.w3.org/TR/ldp/#dfn-linked-data-platform-resource for a 
   #   definition of 'Resource' in LDP
   class Resource
     # @!attribute [r] subject_uri
-    #   an rdf term
+    #   an rdf term identifying the `Resource`
     attr_reader :subject_uri
 
     # @!attribute [rw] metagraph
@@ -159,14 +201,23 @@ module RDF::LDP
     #   input. This MAY be used as a content type for the created Resource 
     #   (especially for `LDP::NonRDFSource`s).
     #
+    # @yield gives a transaction (changeset) to collect changes to graph,
+    #  metagraph and other resources' (e.g. containers) graphs
+    # @yieldparam tx [RDF::Transaction]
+    # @return [RDF::LDP::Resource] self
+    #
     # @raise [RDF::LDP::RequestError] when creation fails. May raise various 
     #   subclasses for the appropriate response codes.
     # @raise [RDF::LDP::Conflict] when the resource exists
-    #
-    # @return [RDF::LDP::Resource] self
-    def create(input, content_type)
+    def create(input, content_type, &block)
       raise Conflict if exists?
-      metagraph << RDF::Statement(subject_uri, RDF.type, self.class.to_uri)
+
+      @data.transaction do |transaction|
+        set_interaction_model(transaction)
+        yield transaction if block_given?
+        set_last_modified(transaction)
+      end
+
       self
     end
 
@@ -178,12 +229,20 @@ module RDF::LDP
     # @param [#to_s] content_type  a MIME content_type used to interpret the
     #   input.
     #
+    # @yield gives a transaction (changeset) to collect changes to graph,
+    #  metagraph and other resources' (e.g. containers) graphs
+    # @yieldparam tx [RDF::Transaction]
+    # @return [RDF::LDP::Resource] self
+    #
     # @raise [RDF::LDP::RequestError] when update fails. May raise various 
     #   subclasses for the appropriate response codes.
-    #
-    # @return [RDF::LDP::Resource] self
-    def update(input, content_type)
-      raise NotImplementedError
+    def update(input, content_type, &block)
+      return create(input, content_type, &block) unless exists?
+      @data.transaction do |transaction|
+        yield transaction if block_given?
+        set_last_modified(transaction)
+      end
+      self
     end
 
     ##
@@ -192,30 +251,69 @@ module RDF::LDP
     # This adds a statment to the metagraph expressing that the resource has 
     # been deleted
     #
+    # @yield gives a transaction (changeset) to collect changes to graph,
+    #  metagraph and other resources' (e.g. containers) graphs
+    # @yieldparam tx [RDF::Transaction]
     # @return [RDF::LDP::Resource] self
     # 
     # @todo Use of owl:Nothing is probably problematic. Define an internal 
     # namespace and class represeting deletion status as a stateful property.
-    def destroy
-      containers.each { |con| con.remove(self) if con.container? }
-      @metagraph << RDF::Statement(subject_uri, RDF.type, RDF::OWL.Nothing)
+    def destroy(&block)
+      @data.transaction do |transaction|
+        containers.each { |c| c.remove(self, transaction) if c.container? }
+        transaction << RDF::Statement(subject_uri, 
+                                      RDF::Vocab::PROV.invalidatedAtTime,
+                                      DateTime.now,
+                                      graph_name: metagraph_name)
+        yield if block_given?
+      end
       self
     end
 
     ##
+    # Gives the status of the resource's existance.
+    #
+    # @note destroyed resources continue to exist in the sense represeted by 
+    #   this method. 
+    #
     # @return [Boolean] true if the resource exists within the repository
     def exists?
-      @data.has_context? metagraph.context
+      @data.has_graph? metagraph.graph_name
     end
 
     ##
     # @return [Boolean] true if resource has been destroyed
     def destroyed?
-      !(@metagraph.query([subject_uri, RDF.type, RDF::OWL.Nothing]).empty?)
+      times = @metagraph.query([subject_uri, RDF::Vocab::PROV.invalidatedAtTime, nil])
+      !(times.empty?)
     end
 
+    ##
+    # Returns an Etag. This may be a strong or a weak ETag.
+    #
+    # @return [String] an HTTP Etag 
+    #
+    # @note these etags are strong if (and only if) all software that updates
+    #   the resource also updates the ETag
+    #
+    # @see http://www.w3.org/TR/ldp#h-ldpr-gen-etags  LDP ETag clause for GET
+    # @see http://www.w3.org/TR/ldp#h-ldpr-put-precond  LDP ETag clause for PUT
+    # @see http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.3.3 
+    #   description of strong vs. weak validators
     def etag
-      nil
+      return nil unless exists?
+      "W/\"#{last_modified.new_offset(0).iso8601(9)}\""
+    end
+
+    ##
+    # @return [DateTime] the time this resource was last modified
+    #
+    # @todo handle cases where there is more than one RDF::DC.modified.
+    #    check for the most recent date
+    def last_modified
+      results = @metagraph.query([subject_uri, RDF::Vocab::DC.modified, :time])
+      return nil if results.empty?
+      results.first.object.object
     end
 
     ##
@@ -310,7 +408,7 @@ module RDF::LDP
       raise Gone if destroyed?
       begin
         send(method.to_sym.downcase, status, headers, env)
-      rescue NotImplementedError, NoMethodError => e
+      rescue NotImplementedError => e
         raise MethodNotAllowed, method 
       end
     end
@@ -344,6 +442,36 @@ module RDF::LDP
       [204, headers, destroy]
     end
 
+    ##
+    # @abstract implement in subclasses as needed to support HTTP PATCH
+    def patch(*)
+      raise NotImplementedError
+    end
+
+    ##
+    # @abstract implement in subclasses as needed to support HTTP POST
+    def post(*)
+      raise NotImplementedError
+    end
+
+    ##
+    # @abstract implement in subclasses as needed to support HTTP PUT
+    def put(*)
+      raise NotImplementedError
+    end
+
+    ##
+    # @abstract HTTP TRACE is not expected to be supported
+    def trace(*)
+      raise NotImplementedError
+    end
+
+    ##
+    # @abstract HTTP CONNECT is not expected to be supported
+    def connect(*)
+      raise NotImplementedError
+    end
+
     ##
     # @return [RDF::URI] the name for this resource's metagraph
     def metagraph_name
@@ -361,14 +489,19 @@ module RDF::LDP
       headers['Accept-Post'] = accept_post   if respond_to?(:post, true)
       headers['Accept-Patch'] = accept_patch if respond_to?(:patch, true)
 
-      headers['ETag'] ||= etag if etag
+      tag = etag
+      headers['ETag'] ||= tag if tag
+
+      modified = last_modified
+      headers['Last-Modified'] ||= modified.httpdate if modified
+
       headers
     end
 
     ##
     # @return [String] the Accept-Post headers
     def accept_post
-      RDF::Reader.map { |klass| klass.format.content_type }.flatten.join(', ')
+      RDF::Reader.map(&:format).compact.map(&:content_type).flatten.join(', ')
     end
 
     ##
@@ -400,5 +533,36 @@ module RDF::LDP
     def link_type_header(uri)
       "<#{uri}>;rel=\"type\""
     end
+
+    ##
+    # Sets the last modified date/time to now
+    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
+        modified = last_modified
+        transaction.delete RDF::Statement(subject_uri, 
+                                          RDF::Vocab::DC.modified, 
+                                          modified,
+                                          graph_name: metagraph_name) if modified
+
+        transaction.insert RDF::Statement(subject_uri, 
+                                          RDF::Vocab::DC.modified, 
+                                          DateTime.now,
+                                          graph_name: metagraph_name)
+      else
+        metagraph.update([subject_uri, RDF::Vocab::DC.modified, DateTime.now])
+      end  
+    end
+
+    ##
+    # Sets the last modified date/time to the URI for this resource's class
+    def set_interaction_model(transaction)
+      transaction.insert(RDF::Statement(subject_uri, 
+                                        RDF.type, 
+                                        self.class.to_uri,
+                                        graph_name: metagraph.graph_name))
+    end
   end
 end

metadata

@@ -1,87 +1,99 @@
 --- !ruby/object:Gem::Specification
 name: rdf-ldp
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Tom Johnson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-30 00:00:00.000000000 Z
+date: 2016-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: rdf
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.99'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.99'
 - !ruby/object:Gem::Dependency
-  name: ld-patch
+  name: rdf-turtle
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.8
 - !ruby/object:Gem::Dependency
-  name: rdf-vocab
+  name: ld-patch
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.1'
 - !ruby/object:Gem::Dependency
-  name: rack-linkeddata
+  name: rdf-vocab
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.8.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.8.4
 - !ruby/object:Gem::Dependency
-  name: rdf-turtle
+  name: rack-linkeddata
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -98,44 +110,50 @@ dependencies:
   name: json-ld
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: sinatra
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: link_header
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.8
 - !ruby/object:Gem::Dependency
   name: rdf-spec
   requirement: !ruby/object:Gem::Requirement
@@ -230,16 +248,16 @@ dependencies:
   name: rack-test
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.6'
 - !ruby/object:Gem::Dependency
   name: rspec-its
   requirement: !ruby/object:Gem::Requirement
@@ -254,6 +272,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
@@ -297,6 +329,7 @@ files:
 - README.md
 - UNLICENSE
 - VERSION
+- app/lamprey.rb
 - bin/lamprey
 - lib/rack/ldp.rb
 - lib/rdf/ldp.rb
@@ -328,7 +361,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: A suite of LDP software and middleware for RDF.rb.