ldp 0.0.3 → 0.0.4

data/lib/ldp/resource.rb

@@ -1,20 +1,15 @@
 module Ldp
   class Resource
+    require 'ldp/resource/binary_source'
+    require 'ldp/resource/rdf_source'
 
     attr_reader :client, :subject
+    attr_accessor :content
 
-    ##
-    # Create a new LDP resource with a blank RDF graph
-    def self.create client, subject
-      self.new client, subject, RDF::Graph.new
-    end
-
-    def initialize client, subject, graph_or_response = nil
+    def initialize client, subject, response = nil
       @client = client
       @subject = subject
-
-      @graph = graph_or_response if graph_or_response.is_a? RDF::Graph
-      @get = graph_or_response if graph_or_response.is_a? Ldp::Response
+      @get = response if response.is_a? Faraday::Response and current? response
     end
 
     ##
@@ -26,13 +21,15 @@ module Ldp
     ##
     # Reload the LDP resource
     def reload
-      Ldp::Resource.new client, subject
+      self.class.new client, subject, @get
     end
 
     ##
     # Is the resource new, or does it exist in the LDP server?
     def new?
-      get
+      subject.nil? || !head
+    rescue Ldp::NotFound
+      true
     end
 
     ##
@@ -44,9 +41,11 @@ module Ldp
     ##
     # Get the resource
     def get
-      @get ||= client.get(subject).tap do |result|
-        raise NotFound if result.status == 404
-      end
+      @get ||= client.get(subject)
+    end
+    
+    def head
+      @head ||= @get || client.head(subject)
     end
 
     ##
@@ -56,75 +55,45 @@ module Ldp
         req.headers['If-Match'] = get.etag if retrieved_content?
       end
     end
-
+    
+    def save
+      new? ? create : update
+    end
+    
     ##
     # Create a new resource at the URI
-    def create
-      raise "" if new?
-      resp = client.post '', graph.dump(:ttl) do |req|
-        req.headers['Slug'] = subject
+    # @return [RdfSource] the new representation
+    def create &block
+      raise "Can't call create on an existing resource" unless new?
+      resp = client.post((subject || ""), content) do |req|
+        
+        yield req if block_given?
       end
 
       @subject = resp.headers['Location']
       @subject_uri = nil
+      reload
     end
-
+    
     ##
     # Update the stored graph
-    def update new_graph = nil
-      new_graph ||= graph
-      client.put subject, new_graph.dump(:ttl) do |req|
+    def update new_content = nil
+      new_content ||= content
+      client.put subject, new_content do |req|
         req.headers['If-Match'] = get.etag if retrieved_content?
       end
     end
 
-    def graph
-      @graph ||= begin
-        original_graph = get.graph
-
-        inlinedResources = get.graph.query(:predicate => Ldp.inlinedResource).map { |x| x.object }
-
-        unless inlinedResources.empty?
-          new_graph = RDF::Graph.new
-
-          original_graph.each_statement do |s|
-            unless inlinedResources.include? s.subject
-              new_graph << s
-            end
-          end
+    def current? response = nil
+      response ||= @get
+      return true if new? and subject.nil?
+      
+      new_response = client.head(subject)
 
-          new_graph
-        else
-          original_graph
-        end
-      end
-    end
-
-    def self.check_for_differences_and_reload_resource old_object
-      new_object = old_object.reload
-
-      bijection = new_object.graph.bijection_to(old_object.graph)
-      diff = RDF::Graph.new
-
-      old_object.graph.each do |statement|
-        if statement.has_blank_nodes?
-          subject = bijection.fetch(statement.subject, false) if statement.subject.node?
-          object = bijection.fetch(statement.object, false) if statement.object.node?
-          bijection_statement = RDF::Statement.new :subject => subject || statemnet.subject, :predicate => statement.predicate, :object => object || statement.object
-
-          diff << statement if subject === false or object === false or new_object.graph.has_statement?(bijection_statement)
-        elsif !new_object.graph.has_statement? statement
-          diff << statement
-        end
-      end
-
-      diff
-    end
-
-    ##
-    # Reload this resource as an LDP container
-    def as_container
-      Ldp::Container.new client, subject, @graph || @get
+      response.headers['ETag'] &&
+        response.headers['Last-Modified'] &&
+        new_response.headers['ETag'] == response.headers['ETag'] &&
+        new_response.headers['Last-Modified'] == response.headers['Last-Modified']
     end
   end
 end

data/lib/ldp/response/paging.rb

@@ -0,0 +1,57 @@
+module Ldp
+  module Response::Paging  
+    ##
+    # Statements about the page
+    def page
+      @page_graph ||= begin
+        g = RDF::Graph.new  
+
+        if resource?
+          res = graph.query RDF::Statement.new(page_subject, nil, nil)
+
+          res.each_statement do |s|
+            g << s
+          end
+        end
+
+        g
+      end
+    end
+    
+    ##
+    # Get the subject for the response
+    def subject
+      @subject ||= if has_page?
+        graph.first_object [page_subject, Ldp.page_of, nil]
+      else
+        page_subject
+      end
+    end
+
+    ##
+    # Is there a next page?
+    def has_next?
+      next_page != nil
+    end
+
+    ##
+    # Get the URI for the next page
+    def next_page
+      graph.first_object [page_subject, Ldp.nextPage, nil]
+    end
+
+    ##
+    # Get the URI to the first page
+    def first_page
+      if links['first']
+        RDF::URI.new links['first']
+      elsif graph.has_statement? RDf::Statement.new(page_subject, Ldp.nextPage, nil)
+        subject
+      end
+    end
+
+    def sort
+
+    end
+  end 
+end

data/lib/ldp/response.rb

@@ -1,33 +1,62 @@
 module Ldp
   module Response
+    require 'ldp/response/paging'
 
     ##
     # Wrap the raw Faraday respone with our LDP extensions
     def self.wrap client, raw_resp
       raw_resp.send(:extend, Ldp::Response)
-      raw_resp.ldp_client = client
+      raw_resp.send(:extend, Ldp::Response::Paging) if raw_resp.has_page?
       raw_resp
     end
 
     ##
     # Extract the Link: headers from the HTTP resource
-    def self.links raw_resp
-      h = Hash.new { |hash, key| hash[key] = [] }
-      Array(raw_resp.headers["Link"]).map { |x| x.split(", ") }.flatten.inject(h) do |memo, header|
-        v = header.scan(/(.*);\s?rel="([^"]+)"/)
-
-        if v.length == 1
-          memo[v.first.last] << v.first.first
+    def self.links response
+      h = {}
+      Array(response.headers["Link"]).map { |x| x.split(", ") }.flatten.inject(h) do |memo, header|
+        m = header.match(/(?<link>.*);\s?rel="(?<rel>[^"]+)"/)
+        if m
+          memo[m[:rel]] ||= []
+          memo[m[:rel]] << m[:link]
         end
 
         memo
       end
     end
+    
+    def self.applied_preferences headers
+      h = {}
+      
+      Array(headers).map { |x| x.split(",") }.flatten.inject(h) do |memo, header|
+        m = header.match(/(?<key>[^=;]*)(=(?<value>[^;,]*))?(;\s*(?<params>[^,]*))?/)
+        includes = (m[:params].match(/include="(?<include>[^"]+)"/)[:include] || "").split(" ")
+        omits = (m[:params].match(/omit="(?<omit>[^"]+)"/)[:omit] || "").split(" ")
+        memo[m[:key]] = { value: m[:value], includes: includes, omits: omits }
+      end
+    end
 
     ##
     # Is the response an LDP resource?
-    def self.resource? raw_resp
-      links(raw_resp).fetch("type", []).include? Ldp.resource.to_s
+
+    def self.resource? response
+      Array(links(response)["type"]).include? Ldp.resource.to_s
+    end
+
+    ##
+    # Is the response an LDP container?
+    def self.container? response
+      [
+        Ldp.basic_container, 
+        Ldp.direct_container, 
+        Ldp.indirect_container
+      ].any? { |x| Array(links(response)["type"]).include? x.to_s }
+    end
+    
+    ##
+    # Link: headers from the HTTP response
+    def links
+      @links ||= Ldp::Response.links(self)
     end
 
     ##
@@ -39,17 +68,16 @@ module Ldp
     ##
     # Is the response an LDP container
     def container?
-      graph.has_statement? RDF::Statement.new(subject, RDF.type, Ldp.container)
+      Ldp::Response.container?(self)
     end
 
+    def preferences
+      Ldp::Resource.applied_preferences(headers["Preference-Applied"])
+    end
     ##
     # Get the subject for the response
     def subject
-      @subject ||= if has_page?
-        graph.first_object [page_subject, Ldp.page_of, nil]
-      else
-        page_subject
-      end
+      page_subject
     end
 
     ##
@@ -59,15 +87,9 @@ module Ldp
     end
 
     ##
-    # Set the LDP client for this resource
-    def ldp_client= client
-      @ldp_client = client
-    end
-
-    ##
-    # Get the LDP client
-    def ldp_client
-      @ldp_client
+    # Is the response paginated?
+    def has_page?
+      graph.has_statement? RDF::Statement.new(page_subject, RDF.type, Ldp.page)
     end
 
     ##
@@ -101,77 +123,19 @@ module Ldp
     end
 
     ##
-    # Statements about the page
-    def page
-      @page_graph ||= begin
-        g = RDF::Graph.new  
-
-        if resource?
-          res = graph.query RDF::Statement.new(page_subject, nil, nil)
-
-          res.each_statement do |s|
-            g << s
-          end
-        end
-
-        g
-      end
+    # Extract the Link: rel="type" headers for the resource
+    def types
+      Array(links["type"])
     end
-
-    ##
-    # Is the response paginated?
-    def has_page?
-      graph.has_statement? RDF::Statement.new(page_subject, RDF.type, Ldp.page)
-    end
-
-    ##
-    # Is there a next page?
-    def has_next?
-      next_page != nil
-    end
-
-    ##
-    # Get the URI for the next page
-    def next_page
-      graph.first_object [page_subject, Ldp.nextPage, nil]
-    end
-
-    ##
-    # Get the URI to the first page
-    def first_page
-      if links['first']
-        RDF::URI.new links['first']
-      elsif graph.has_statement? RDf::Statement.new(page_subject, Ldp.nextPage, nil)
-        subject
-      end
-    end
-
-    ##
-    # Get a list of inlined resources
-    def resources
-      graph.query RDF::Statement.new(page_subject, Ldp.inlinedResource, nil)
-    end
-
-    ##
-    # Get a list of member resources
-    def members
-      graph.query RDF::Statement.new(page_subject, membership_predicate, nil)
-    end
-
-    ##
-    # Predicate to use to determine container membership
-    def membership_predicate
-      graph.first_object [page_subject, Ldp.membership_predicate, nil]
+    
+    def includes? preference
+      key = Ldp.send("prefer_#{preference}") if Ldp.respond_to("prefer_#{preference}")
+      key ||= preference
+      preferences["return"][:includes].include?(key) || !preferences["return"][:omits].include?(key) 
     end
-
-    def sort
-
-    end
-
-    ##
-    # Link: headers from the HTTP response
-    def links
-      Ldp::Response.links(self)
+    
+    def minimal?
+      preferences["return"][:value] == "minimal"
     end
   end
-end
+end

data/lib/ldp/uri.rb

@@ -12,6 +12,22 @@ module Ldp::Uri
     uri("Container")
   end
 
+  def basic_container
+    uri("BasicContainer")
+  end
+  
+  def direct_container
+    uri("DirectContainer")
+  end
+  
+  def indirect_container
+    uri("IndirectContainer")
+  end
+  
+  def contains
+    uri("contains")
+  end
+  
   def page
     uri("Page")
   end
@@ -24,12 +40,28 @@ module Ldp::Uri
     uri("nextPage")
   end
 
-  def inlinedResource
-    uri("inlinedResource")
-  end
-
   def membership_predicate
     uri("membershipPredicate")
   end
+  
+  def prefer_empty_container
+    uri("PreferEmptyContainer")
+  end
+  
+  def prefer_membership
+    uri("PreferMembership")
+  end
+  
+  def prefer_containment
+    uri("PreferContainment")
+  end
+  
+  def has_member_relation
+    uri("hasMemberRelation")
+  end
+  
+  def member
+    uri("member")
+  end
 
-end
+end

data/lib/ldp/version.rb

@@ -1,3 +1,3 @@
 module Ldp
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/ldp.rb

@@ -1,6 +1,7 @@
 require 'ldp/version'
 require 'linkeddata'
 require 'logger'
+require 'http_logger'
 
 module Ldp
   RDF::Graph.send(:include, RDF::Isomorphic)
@@ -16,7 +17,8 @@ module Ldp
 
   autoload :Orm, 'ldp/orm'
 
-  class NotFound < StandardError; end
+  class HttpError < RuntimeError; end
+  class NotFound < HttpError; end
 
   class << self
     def logger
@@ -24,6 +26,14 @@ module Ldp
         log.level = Logger::WARN
       end
     end
+    
+    def instrument *args, &block
+      if defined?(::ActiveSupport) && defined?(::ActiveSupport::Notifications)
+        ActiveSupport::Notifications.instrument *args, &block
+      else
+        yield
+      end
+    end
 
     attr_writer :logger
   end

data/spec/lib/ldp/client_spec.rb

@@ -1,45 +1,51 @@
 require 'spec_helper'
 describe "Ldp::Client" do
 
-    let(:simple_graph) do
-      graph = RDF::Graph.new << [RDF::URI.new(""), RDF::DC.title, "Hello, world!"]
-      graph.dump(:ttl)
-    end
+  let(:simple_graph) do
+    graph = RDF::Graph.new << [RDF::URI.new(""), RDF::DC.title, "Hello, world!"]
+    graph.dump(:ttl)
+  end
 
 
-    let(:paginatedGraph) do
-      graph = RDF::Graph.new << [RDF::URI.new(""), RDF::DC.title, "Hello, world!"]
-      graph << [RDF::URI.new("?firstPage"), RDF.type, Ldp.page]
-      graph << [RDF::URI.new("?firstPage"), Ldp.page_of, RDF::URI.new("")]
-      graph.dump(:ttl)
-    end
+  let(:paginatedGraph) do
+    graph = RDF::Graph.new << [RDF::URI.new(""), RDF::DC.title, "Hello, world!"]
+    graph << [RDF::URI.new("?firstPage"), RDF.type, Ldp.page]
+    graph << [RDF::URI.new("?firstPage"), Ldp.page_of, RDF::URI.new("")]
+    graph.dump(:ttl)
+  end
 
-    let(:simple_container_graph) do
-      graph = RDF::Graph.new << [RDF::URI.new(""), RDF.type, Ldp.container]
-      graph.dump(:ttl)
-    end
+  let(:simple_container_graph) do
+    graph = RDF::Graph.new << [RDF::URI.new(""), RDF.type, Ldp.container]
+    graph.dump(:ttl)
+  end
 
-    let(:conn_stubs) do
-      stubs = Faraday::Adapter::Test::Stubs.new do |stub|
-        stub.get('/a_resource') {[ 200, {"Link" => "http://www.w3.org/ns/ldp#Resource;rel=\"type\""}, simple_graph ]}
-        stub.get('/a_container') {[ 200, {"Link" => "http://www.w3.org/ns/ldp#Resource;rel=\"type\""}, simple_container_graph ]}
-        stub.put("/a_resource") { [204]}
-        stub.delete("/a_resource") { [204]}
-        stub.post("/a_container") { [201, {"Location" => "http://example.com/a_container/subresource"}]}
-      end
+  let(:conn_stubs) do
+    stubs = Faraday::Adapter::Test::Stubs.new do |stub|
+      stub.head('/a_resource') {[ 200 ]}  
+      stub.get('/a_resource') {[ 200, {"Link" => "http://www.w3.org/ns/ldp#Resource;rel=\"type\""}, simple_graph ]}
+      stub.get('/a_container') {[ 200, {"Link" => ["http://www.w3.org/ns/ldp#Resource;rel=\"type\"","http://www.w3.org/ns/ldp#BasicContainer;rel=\"type\""]}, simple_container_graph ]}
+      stub.head('/a_binary_resource') { [200]}    
+      stub.get('/a_binary_resource') { [200, {}, ""]}
+      stub.put("/a_resource") { [204]}
+      stub.delete("/a_resource") { [204]}
+      stub.head('/a_container') {[ 200 ]}  
+      stub.post("/a_container") { [201, {"Location" => "http://example.com/a_container/subresource"}]}
+      stub.get("/test:1") { [200] }
+      stub.get("http://test:8080/abc") { [200] }
     end
+  end
 
-    let(:mock_conn) do
-      test = Faraday.new do |builder|
-        builder.adapter :test, conn_stubs do |stub|
-        end
+  let(:mock_conn) do
+    test = Faraday.new do |builder|
+      builder.adapter :test, conn_stubs do |stub|
       end
-
     end
 
-    subject do
-      Ldp::Client.new mock_conn
-    end
+  end
+
+  subject do
+    Ldp::Client.new mock_conn
+  end
 
   describe "initialize" do
     it "should accept an existing Faraday connection" do
@@ -66,6 +72,36 @@ describe "Ldp::Client" do
     it "should accept a block to change the HTTP request" do
       expect { |b| subject.get "a_resource", &b }.to yield_control
     end
+    
+    context "should provide convenient accessors for LDP Prefer headers" do
+      it "should set the minimal header" do
+        subject.get "a_resource", minimal: true do |req|
+          expect(req.headers["Prefer"]).to eq "return=minimal"
+        end
+      end
+      it "should set the include parameter" do
+        subject.get "a_resource", include: "membership" do |req|
+          expect(req.headers["Prefer"]).to match "include=\"#{Ldp.prefer_membership}\""
+        end
+      end
+      it "should set the omit parameter" do
+        subject.get "a_resource", omit: "containment" do |req|
+          expect(req.headers["Prefer"]).to match "omit=\"#{Ldp.prefer_containment}\""
+        end
+      end
+    end
+    
+    context "with an invalid relative uri" do
+      it "should work" do
+        subject.get "test:1"
+      end
+    end
+    
+    context "with an absolute uri" do
+      it "should work" do
+        subject.get "http://test:8080/abc"
+      end
+    end
   end
 
   describe "delete" do
@@ -143,6 +179,11 @@ describe "Ldp::Client" do
       expect(resource).to be_a_kind_of(Ldp::Resource)
       expect(resource).to be_a_kind_of(Ldp::Container)
     end
+    
+    it "should be a binary resource" do
+      resource = subject.find_or_initialize "a_binary_resource"
+      expect(resource).to be_a_kind_of(Ldp::Resource::BinarySource)
+    end
 
   end
 end