rdf-ldp 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 76067ed8fd6b28e3c35eb9bcb65d14585cd4e0fe
-  data.tar.gz: 098810c5faf3aca4dd7bc0992797eb1d4d309c67
+  metadata.gz: 96681a7e685f8af473a2bfe9a2b25ffdb147a057
+  data.tar.gz: 80a4b2e3efa3ec7aa7c41a0c6f252d67431babc0
 SHA512:
-  metadata.gz: 0fcb758fa163d0c6e229af2286f7332fd1561df33f56f23786e36de7a524dcfe6cb7457f0c26e06faf9cf6d7519f56df58a9b82958ff9e8e7e0398365cba6fe1
-  data.tar.gz: 465af32bf8ca54109cf01b555d626cc6e229ef83ffabc30d69eebd5ad1142697f3624cfbc38e618e1acf03b3b684d0e070a4bb36a157aba97ff802c10940d1f3
+  metadata.gz: fd5442ef53e136c2dc83bc6fc5cb2d4c35b66d6e2be7669abd1c7d6eb5888d4fa5ecae8ccdfeb888d6e702675dbe1e2cab6f98ff01cd142c03f8baf826b86c30
+  data.tar.gz: 1acbe59831cd7219ffb933957c96d67cbc16b21c4cd949d81b60f60201cba4c88490a4c2ab1897bae69a249858e2db77f4febe6c99a293da621de2e9b08a62d6

data/AUTHORS

@@ -0,0 +1 @@
+* Tom Johnson <tom@dp.la>

data/README.md

@@ -1,37 +1,59 @@
-# DEPRECATED - use rdf-vocab
+RDF::LDP
+========
 
-This gem is deprecated;  rdf-vocab gem (https://github.com/ruby-rdf/rdf-vocab, included in the linkeddata gem) now contains RDF::Vocab::LDP.  You can find the  helper method to strip LDP triples from an RDF::Graph object in the triannon gem in lib/oa_graph_helper.rb.
+[![Build Status](https://travis-ci.org/ruby-rdf/rdf-ldp.svg?branch=develop)](https://travis-ci.org/ruby-rdf/rdf-ldp)
 
-# rdf-ldp
+This software ships with the following libraries:
 
-[![Build Status](https://travis-ci.org/sul-dlss/rdf-ldp.svg)](https://travis-ci.org/sul-dlss/rdf-ldp) [![Dependency Status](https://gemnasium.com/sul-dlss/rdf-ldp.svg)](https://gemnasium.com/sul-dlss/rdf-ldp) [![Gem Version](https://badge.fury.io/rb/rdf-ldp.svg)](http://badge.fury.io/rb/rdf-ldp)
+  - `RDF::LDP` --- contains the domain model for LDP Resources.
+  - `Rack::LDP` --- a suite of Rack middleware for creating LDP servers based on
+  `RDF::LDP`.
+  - Lamprey --- a basic LDP server implemented with `Rack::LDP`.
 
-Contains vocabularies to be used by RDF ruby gem https://github.com/ruby-rdf/rdf/ to simplify coding when using LDP data.
+Lamprey
+=======
 
-Also contains helper method to strip LDP triples from an RDF::Graph object.
+Lamprey is a basic LDP server. To start it, use:
 
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'rdf-vocab'  # (was rdf-ldp)
+```
+bundle exec ruby app/lamprey.rb
 ```
 
-And then execute:
+An `ldp:BasicContainer` will be created at the address of your first
+`GET` request. Note that if that request is made to the server root,
+Sinatra will assume a trailing slash.
+
+```bash
+$ curl -i http://localhost:4567
+
+HTTP/1.1 200 OK
+Content-Type: text/turtle
+Link: <http://www.w3.org/ns/ldp#Resource>;rel="type",<http://www.w3.org/ns/ldp#RDFSource>;rel="type",<http://www.w3.org/ns/ldp#BasicContainer>;rel="type"
+Allow: GET, POST, PUT, DELETE, OPTIONS, HEAD
+Accept-Post: application/n-triples, text/plain, application/n-quads, text/x-nquads, application/ld+json, application/x-ld+json, application/rdf+json, text/html, text/n3, text/rdf+n3, application/rdf+n3, application/rdf+xml, text/csv, text/tab-separated-values, application/csvm+json, text/turtle, text/rdf+turtle, application/turtle, application/x-turtle, application/trig, application/x-trig, application/trix
+Etag: "1B2M2Y8AsgTpgAmY7PhCfg==0"
+Vary: Accept
+X-Content-Type-Options: nosniff
+Server: WEBrick/1.3.1 (Ruby/2.1.0/2013-12-25)
+Date: Mon, 27 Jul 2015 23:19:06 GMT
+Content-Length: 0
+Connection: Keep-Alive
+```
 
-    $ bundle
+Compliance
+----------
 
-Or install it yourself as:
+Current compliance reports for Lamprey are located in [/reports](reports/).
+Reports are generated by the LDP test suite. To duplicate the results,
+use the `testsuite` branch, which contains a work-around for
+[w3c/ldp-testsuite#224](https://github.com/w3c/ldp-testsuite/issues/224).
 
-    $ gem install rdf-vocab  # (was rdf-ldp)
+License
+========
 
-## Usage
+This software is released under a public domain waiver (Unlicense).
 
-    require 'rdf/vocab'
+  
 
-    RDF::Vocab::LDP.member    #=> RDF::URI("http://www.w3.org/ns/ldp#member")
 
-# DEPRECATED - use rdf-vocab
 
-This gem is deprecated;  rdf-vocab gem (https://github.com/ruby-rdf/rdf-vocab, included in the linkeddata gem) now contains RDF::Vocab::LDP.  You can find the  helper method to strip LDP triples from an RDF::Graph object in the triannon gem in lib/oa_graph_helper.rb.

data/UNLICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org/>

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/lib/rack/ldp.rb

@@ -0,0 +1,121 @@
+require 'rack'
+begin
+  require 'linkeddata'
+rescue LoadError => e
+  require 'rdf/turtle'
+  require 'json/ld'
+end
+
+require 'rack/linkeddata'
+require 'rdf/ldp'
+
+module Rack
+  ##
+  # 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 
+  # without alteration, allowing server implementers to mix LDP interaction
+  # patterns with others on the same server.
+  #
+  # 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.
+  #
+  # @example
+  #   run Rack:;Builder.new do
+  #     use Rack::LDP::ContentNegotiation
+  #     use Rack::LDP::Errors
+  #     use Rack::LDP::Responses
+  #     # ...
+  #   end
+  # 
+  # @see http://www.w3.org/TR/ldp/ the LDP specification
+  module LDP
+    ##
+    # Catches and handles RequestErrors thrown by RDF::LDP
+    class Errors
+      ##
+      # @param  [#call] app
+      def initialize(app)
+        @app = app
+      end
+
+      ##
+      # Catches {RDF::LDP::RequestError} and its various subclasses, building an 
+      # appropriate response 
+      #
+      # @param [Array] env  a rack env array
+      # @return [Array]  a rack env array with added headers
+      def call(env)
+        begin
+          @app.call(env)
+        rescue RDF::LDP::RequestError => err
+          return [err.status, err.headers, [err.message]]
+        end
+      end
+    end
+
+    ##
+    # Converts RDF::LDP::Resource} into appropriate responses
+    class Responses
+      ##
+      # @param  [#call] app
+      def initialize(app)
+        @app = app
+      end
+
+      ##
+      # Converts the response body from {RDF::LDP::Resource} form to a Graph
+      def call(env)
+        status, headers, response = @app.call(env)
+
+        if response.is_a? RDF::LDP::Resource
+          new_response = response.to_response
+          response.close if response.respond_to? :close
+          response = new_response
+        end
+
+        [status, headers, response]
+      end
+    end
+
+    ##
+    #
+    class Requests
+      ##
+      # @param  [#call] app
+      def initialize(app)
+        @app = app
+      end
+
+      ##
+      # Handles a Rack protocol request. Sends appropriate request to the 
+      # object, alters response accordingly.
+      #
+      # @param [Array] env  a rack env array
+      # @return [Array]  a rack env array with added headers
+      def call(env)
+        status, headers, response = @app.call(env)
+        return [status, headers, response] unless
+          response.is_a? RDF::LDP::Resource
+        
+        response
+          .send(:request, env['REQUEST_METHOD'].to_sym, status, headers, env)
+      end
+    end
+
+    ##
+    # Specializes {Rack::LinkedData::ContentNegotiation}, making the default 
+    # return type 'text/turtle'
+    class ContentNegotiation < Rack::LinkedData::ContentNegotiation
+      def initialize(app, options = {})
+        options[:default] ||= 'text/turtle'
+        super
+      end
+    end
+  end
+end

data/lib/rdf/ldp/container.rb

@@ -0,0 +1,143 @@
+module RDF::LDP
+  class Container < RDFSource
+    ##
+    # @return [RDF::URI] uri with lexical representation 
+    #   'http://www.w3.org/ns/ldp#Container'
+    def self.to_uri
+      RDF::Vocab::LDP.Container
+    end
+
+    ##
+    # @return [Boolean] whether this is an ldp:Container
+    def container?
+      true
+    end
+
+    ##
+    # @return [RDF::URI] a URI representing the container type
+    def container_class
+      CONTAINER_CLASSES[:basic]
+    end
+
+    ##
+    # @see RDFSource#create
+    def create(input, content_type)
+      super { |statements| validate_triples!(statements) }
+    end
+    
+    ##
+    # @see RDFSource#update
+    def update(input, content_type)
+      super { |statements| validate_triples!(statements) }
+    end
+
+    ##
+    # Adds a member `resource` to the container. Handles containment and 
+    # membership triples as appropriate for the container type.
+    #
+    # @param [RDF::Term] a new member for this container
+    # @return [Container] self
+    def add(resource)
+      add_containment_triple(resource.to_uri)
+    end
+
+    ##
+    # Removes a member `resource` from the container. Handles containment and
+    # membership triples as appropriate for the container type.
+    #
+    # @param [RDF::Term] a new member for this container
+    # @return [Container] self
+    def remove(resource)
+      remove_containment_triple(resource.to_uri)
+    end
+
+    ##
+    # @return [RDF::Query::Enumerator] the containment triples
+    def containment_triples
+      graph.query([subject_uri, 
+                   RDF::Vocab::LDP.contains, 
+                   nil]).statements
+    end
+
+    ##
+    # @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?)
+    end
+
+    ##
+    # Adds a containment triple for `resource` to the container's `#graph`.
+    #
+    # @param [RDF::Term] a new member for this container
+    # @return [Container] self
+    def add_containment_triple(resource)
+      graph << make_containment_triple(resource)
+      self
+    end
+
+    ##
+    # Remove a containment triple for `resource` to the container's `#graph`.
+    #
+    # @param [RDF::Term] a member to remove from this container
+    # @return [Container] self
+    def remove_containment_triple(resource)
+      graph.delete(make_containment_triple(resource))
+      self
+    end
+
+    ##
+    # @param [RDF::Term] a member for this container
+    #
+    # @return [RDF::URI] the containment triple
+    def make_containment_triple(resource)
+      RDF::Statement(subject_uri, RDF::Vocab::LDP.contains, resource)
+    end
+
+    private
+
+    ##
+    # Handles a POST request. Parses a graph in the body of `env` and treats all
+    # statements in that graph (irrespective of any graph names) as constituting
+    # the initial state of the created source.
+    #
+    # @raise [RDF::LDP::RequestError] when creation fails
+    #
+    # @return [Array<Fixnum, Hash<String, String>, #each] a new Rack response 
+    #   array.
+    def post(status, headers, env)
+      klass = self.class.interaction_model(env.fetch('HTTP_LINK', ''))
+      slug = env['HTTP_SLUG']
+      slug = klass.gen_id if slug.nil? || slug.empty?
+      raise NotAcceptable.new('Refusing to create resource with `#` in Slug') if 
+        slug.include? '#'
+
+      id = (subject_uri / slug).canonicalize
+
+      created = klass.new(id, @data)
+                .create(env['rack.input'], env['CONTENT_TYPE'])
+      
+      add(created)
+      headers['Location'] = created.subject_uri.to_s
+      [201, created.send(:update_headers, headers), created]
+    end
+
+    def validate_triples!(statements)
+      existing_triples = containment_triples.to_a
+      statements.query(subject: subject_uri, 
+                       predicate: RDF::Vocab::LDP.contains) do |statement|
+        existing_triples.delete(statement) do 
+          raise Conflict.new('Attempted to write unacceptable LDP ' \
+                             "containment-triple: #{statement}") 
+        end
+      end
+      raise Conflict.new('Cannot remove containment triples in updates. ' \
+                         "Attepted to remove #{existing_triples}") unless
+        existing_triples.empty?
+    end
+  end
+end

data/lib/rdf/ldp/direct_container.rb

@@ -0,0 +1,112 @@
+module RDF::LDP
+  class DirectContainer < Container
+    def self.to_uri
+      RDF::Vocab::LDP.DirectContainer
+    end
+
+    RELATION_TERMS = [RDF::Vocab::LDP.hasMemberRelation,
+                      RDF::Vocab::LDP.isMemberOfRelation]
+
+    ##
+    # @return [RDF::URI] a URI representing the container type
+    def container_class
+      CONTAINER_CLASSES[:direct]
+    end
+
+    def add(resource)
+      process_membership_resource(resource.to_uri) do |membership, triple|
+        super
+        membership.graph << triple
+      end
+    end
+
+    def remove(resource)
+      process_membership_resource(resource.to_uri) do |membership, triple|
+        super
+        membership.graph.delete(triple)
+      end
+    end
+
+    ##
+    # Aliases #subject_uri
+    # @return [RDF::URI] #subject_uri
+    def membership_constant_uri
+      case membership_resource_statements.count
+        when 0
+          graph << RDF::Statement(subject_uri, 
+                                  RDF::Vocab::LDP.membershipResource, 
+                                  subject_uri)
+          subject_uri
+        when 1
+          membership_resource_statements.first.object
+        else
+          raise NotAcceptable.new('An LDP-DC MUST have exactly ' \
+                                  'one membership resource; found ' \
+                                  "#{membership_resource_statements.count}.")
+      end
+    end
+
+    ##
+    # @return [RDF::URI] the membership predicate
+    # @see http://www.w3.org/TR/ldp/#dfn-membership-predicate
+    def membership_predicate
+      case member_relation_statements.count
+      when 0
+        graph << RDF::Statement(subject_uri, 
+                                RELATION_TERMS.first, 
+                                RDF::Vocab::LDP.member)
+        RDF::Vocab::LDP.member
+      when 1
+        member_relation_statements.first.object
+      else
+        raise NotAcceptable.new('An LDP-DC MUST have exactly ' \
+                                'one member relation triple; found ' \
+                                "#{member_relation_statements.count}.")
+      end
+    end
+
+    ##
+    # @param [RDF::Term] a member for this container
+    #
+    # @return [RDF::URI] the membership triple to be added to the 
+    def make_membership_triple(resource)
+      predicate = membership_predicate
+      return RDF::Statement(membership_constant_uri, predicate, resource) if
+        member_relation_statements.first.predicate == RELATION_TERMS.first
+      RDF::Statement(resource, predicate, membership_constant_uri)
+    end
+
+    private
+    
+    def membership_resource_statements
+      graph.query([subject_uri, RDF::Vocab::LDP.membershipResource, :o])
+    end
+
+    def member_relation_statements
+      graph.statements.select do |st| 
+        st.subject == subject_uri && RELATION_TERMS.include?(st.predicate)
+      end
+    end
+
+    def membership_resource
+      uri = membership_constant_uri
+      uri = uri.fragment ? (uri.root / uri.request_uri) : uri
+      RDF::LDP::Resource.find(uri, @data)
+    end
+
+    def process_membership_resource(resource, &block)
+      triple = make_membership_triple(resource)
+
+      begin
+        membership_rs = membership_resource
+      rescue NotFound => e
+        raise NotAcceptable.new('Membership resource ' \
+                                "#{membership_constant_uri} does not exist")
+      end
+
+      yield(membership_resource, triple, resource) if block_given?
+
+      self
+    end
+  end
+end

data/lib/rdf/ldp/indirect_container.rb

@@ -0,0 +1,13 @@
+module RDF::LDP
+  class IndirectContainer < DirectContainer
+    def self.to_uri
+      RDF::Vocab::LDP.IndirectContainer
+    end
+
+    ##
+    # @return [RDF::URI] a URI representing the container type
+    def container_class
+      CONTAINER_CLASSES[:indirect]
+    end
+  end
+end

data/lib/rdf/ldp/non_rdf_source.rb

@@ -0,0 +1,18 @@
+module RDF::LDP
+  class NonRDFSource < Resource
+    ##
+    # @return [RDF::URI] uri with lexical representation 
+    #   'http://www.w3.org/ns/ldp#NonRDFSource'
+    #
+    # @see http://www.w3.org/TR/ldp/#dfn-linked-data-platform-non-rdf-source
+    def self.to_uri 
+      RDF::Vocab::LDP.NonRDFSource
+    end
+
+    ##
+    # @return [Boolean] whether this is an ldp:NonRDFSource
+    def non_rdf_source?
+      true
+    end
+  end
+end