ldp 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 63183c29706de20d216c7ac0701f1c487ac198a1
-  data.tar.gz: e08f80b008698907385b8060d4d2dcaed42ede20
+  metadata.gz: 85a6fa5082ce00c5b29780ec58bdc216286a5cfe
+  data.tar.gz: 884e4e0ea864ddf64270eff48c9ae1fca7d7d70b
 SHA512:
-  metadata.gz: c7ff75b126b3fcf65c11c3a2a5265551f6bb9ea579c9775038a6b5a2decf64799ff8a898473c96be70232671526ffcabf278538dca1b49a98b5246c31ac4c44e
-  data.tar.gz: ecd3068a5a86397768f428e142be9832b587f5474629fb2c0c68a3364128ea1a9b67fb15471323f0ddaba2e0c09ada6f00cc898670481f8ab6a393d914902a41
+  metadata.gz: 7061275707496fd834cc225c3fe6ff1ac6eaf7bd8d01ef63677b8fbd30c24c1038a16ee0646c35b59e452f2c988d2c8d908c1c1011c200812dc3b379cbcc7212
+  data.tar.gz: 40a58400110d941f10212a0b56bfa4cca92d0244372a4e7769a9fdda746c7444de04eefac95cf3f04863d4d31b52ab980b25ed5a2c1562b2424113951a1a4c05

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - jruby-19mode

data/Gemfile

@@ -3,4 +3,5 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in ldp-client.gemspec
 gemspec
 
-gem "byebug"
+gem 'byebug', :platforms => [:mri_20]
+

data/README.md

@@ -1,12 +1,14 @@
-# Ldp::Client
+# Ldp.rb
 
-TODO: Write a gem description
+[![Build Status](https://travis-ci.org/cbeer/ldp.png?branch=master)](https://travis-ci.org/cbeer/ldp)
+
+Linked Data Platform client library for Ruby
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-    gem 'ldp-client'
+    gem 'ldp'
 
 And then execute:
 
@@ -14,11 +16,31 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install ldp-client
+    $ gem install ldp
 
 ## Usage
 
-TODO: Write usage instructions here
+```ruby
+host = 'http://localhost:8080'
+client = Ldp::Client.new(host)
+resource = Ldp::Resource.new(client, host + '/rest/node/to/update')
+orm = Ldp::Orm.new(resource)
+
+# view the current title(s)
+orm.orm.value(RDF::DC11.title)
+
+# update the title
+orm.graph.delete([orm.resource.subject_uri, RDF::DC11.title, nil])
+orm.graph.insert([orm.resource.subject_uri, RDF::DC11.title, 'a new title'])
+
+# save changes
+orm.save
+```
+
+### Fedora Commons notes
+Due to some discrepancies with alpha version of Fedora Commons, you may need to do some things differently:
+* [Can't load resources from Fedora 4](https://github.com/cbeer/ldp/issues/1)
+* [orm.save with an rdf:type doesn't work with Fedora 4.0.0-alpha-3](https://github.com/cbeer/ldp/issues/2)
 
 ## Contributing
 

data/Rakefile

@@ -1 +1,6 @@
 require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/ldp.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "faraday"
-  spec.add_dependency "linkeddata"
+  spec.add_dependency "linkeddata", ">= 1.1"
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"

data/lib/ldp.rb

@@ -1,21 +1,20 @@
 require 'ldp/version'
+require 'linkeddata'
 
 module Ldp
-  require 'ldp/client'
-
-  def self.resource
-    RDF::URI.new("http://www.w3.org/ns/ldp/Resource")
-  end
+  RDF::Graph.send(:include, RDF::Isomorphic)
 
-  def self.container
-    RDF::URI.new("http://www.w3.org/ns/ldp/Container")
-  end
+  require 'ldp/client'
+  require 'ldp/uri'
 
-  def self.inlinedResource
-    RDF::URI.new("http://www.w3.org/ns/ldp/inlinedResource")
-  end
+  extend Uri
 
   autoload :Response, 'ldp/response'
   autoload :Resource, 'ldp/resource'
   autoload :Container, 'ldp/container'
-end
+
+  autoload :Orm, 'ldp/orm'
+
+  class NotFound < StandardError; end
+  
+end

data/lib/ldp/client.rb

@@ -1,8 +1,11 @@
 require 'faraday'
-require 'linkeddata'
 
 module Ldp
   class Client
+
+    require 'ldp/client/methods'
+
+    include Ldp::Client::Methods
     
     attr_reader :http
 
@@ -14,10 +17,11 @@ module Ldp
       end
     end
 
+    # Find or initialize a new LDP resource by URI
     def find_or_initialize subject
       data = get(subject)
 
-      if !data.is_a? Response
+      unless data.is_a? Response
         raise "#{subject} is not an LDP Resource"
       end
 
@@ -28,43 +32,5 @@ module Ldp
       end
     end
 
-    def get url
-      resp = http.get do |req|                          
-        req.url url
-        yield req if block_given?
-      end
-
-      if Response.resource? resp
-        Response.wrap self, resp
-      else
-        resp
-      end
-    end
-
-    def delete url
-      http.delete do |req|
-        req.url url
-        yield req if block_given?
-      end
-    end
-
-    def post url, body
-      http.post do |req|
-        req.url url
-        req.headers['Content-Type'] = 'text/turtle'
-        req.body = body
-        yield req if block_given?
-      end
-    end
-
-    def put url, body
-      http.put do |req|
-        req.url url
-        req.headers['Content-Type'] = 'text/turtle'
-        req.body = body
-        yield req if block_given?
-      end
-    end
-
   end
 end

data/lib/ldp/client/methods.rb

@@ -0,0 +1,44 @@
+module Ldp::Client::Methods
+
+  # Get a LDP Resource by URI
+  def get url
+    resp = http.get do |req|                          
+      req.url url
+      yield req if block_given?
+    end
+
+    if Ldp::Response.resource? resp
+      Ldp::Response.wrap self, resp
+    else
+      resp
+    end
+  end
+
+  # Delete a LDP Resource by URI
+  def delete url
+    http.delete do |req|
+      req.url url
+      yield req if block_given?
+    end
+  end
+
+  # Post TTL to an LDP Resource
+  def post url, body = nil, headers = {}
+    http.post do |req|
+      req.url url
+      req.headers = {"Content-Type"=>"text/turtle"}.merge headers
+      req.body = body
+      yield req if block_given?
+    end
+  end
+
+  # Update an LDP resource with TTL by URI
+  def put url, body
+    http.put do |req|
+      req.url url
+      req.headers['Content-Type'] = 'text/turtle'
+      req.body = body
+      yield req if block_given?
+    end
+  end
+end

data/lib/ldp/container.rb

@@ -1,7 +1,31 @@
 module Ldp
   class Container < Resource
-    def add graph
-      client.post subject, graph.dump(:ttl)
+    ##
+    # Add a resource to the LDP container
+    def add *args
+      # slug, graph
+      # graph
+      # slug
+
+      case
+      when (args.length > 2 || args.length == 0)
+
+      when (args.length == 2)
+        slug, graph = args
+      when (args.first.is_a? RDF::Graph)
+        slug = nil
+        graph = args.first
+      else
+        slug = args.first
+        graph = RDF::Graph.new
+      end
+
+      resp = client.post subject, graph.dump(:ttl) do |req|
+        req.headers['Slug'] = slug
+      end
+
+      subject = resp.headers['Location']
+      return client.find_or_initialize subject
     end
   end
 end

data/lib/ldp/orm.rb

@@ -0,0 +1,87 @@
+module Ldp
+  class Orm
+
+    attr_reader :resource
+    attr_reader :last_response
+
+    def initialize resource
+      @resource = resource
+    end
+
+    def graph
+      resource.graph
+    end
+
+    def value predicate
+      graph.query(:subject => resource.subject_uri, :predicate => predicate).map do |stmt|
+        stmt.object
+      end
+    end
+
+    def query *args, &block
+      graph.query *args, &block
+    end
+
+    def reload
+      Ldp::Orm.new resource.reload
+    end
+
+    def create
+      nil
+    end
+
+    def save
+      @last_response = resource.update
+
+      diff = Ldp::Resource.check_for_differences_and_reload_resource self
+
+      if diff.any?
+        diff
+      else
+        @last_response.success?
+      end
+    end
+
+    def save!
+      result = save
+
+      if result.is_a? RDF::Graph
+        raise GraphDifferenceException.new "", result
+      elsif !result
+        raise SaveException.new "", @last_response
+      end
+
+      result
+    end
+
+    def delete
+      resource.delete
+    end
+
+    def method_missing meth, *args, &block
+      super
+    end
+
+    def respond_to?(meth)
+      super
+    end
+
+  end
+
+  class GraphDifferenceException < Exception
+    attr_reader :diff
+    def initialize message, diff
+      super(message)
+      @diff = diff
+    end
+  end
+
+  class SaveException < Exception
+    attr_reader :response
+    def initialize message, response
+      super(message)
+      @response = response
+    end
+  end
+end
+

data/lib/ldp/resource.rb

@@ -1,11 +1,81 @@
 module Ldp
   class Resource
+
     attr_reader :client, :subject
 
-    def initialize client, subject, data = nil
+    ##
+    # 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
       @client = client
       @subject = subject
-      @get = data
+
+      @graph = graph_or_response if graph_or_response.is_a? RDF::Graph
+      @get = graph_or_response if graph_or_response.is_a? Ldp::Response
+    end
+
+    ##
+    # Get the graph subject as a URI
+    def subject_uri
+      @subject_uri ||= RDF::URI.new subject
+    end
+
+    ##
+    # Reload the LDP resource
+    def reload
+      Ldp::Resource.new client, subject
+    end
+
+    ##
+    # Is the resource new, or does it exist in the LDP server?
+    def new?
+      get
+    end
+
+    ##
+    # Have we retrieved the content already?
+    def retrieved_content?
+      @get
+    end
+
+    ##
+    # Get the resource
+    def get
+      @get ||= client.get(subject).tap do |result|
+        raise NotFound if result.status == 404
+      end
+    end
+
+    ##
+    # Delete the resource
+    def delete
+      client.delete subject do |req|
+        req.headers['If-Match'] = get.etag if retrieved_content?
+      end
+    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
+      end
+
+      @subject = resp.headers['Location']
+      @subject_uri = nil
+    end
+
+    ##
+    # Update the stored graph
+    def update new_graph = nil
+      new_graph ||= graph
+      client.put subject, new_graph.dump(:ttl) do |req|
+        req.headers['If-Match'] = get.etag if retrieved_content?
+      end
     end
 
     def graph
@@ -14,11 +84,11 @@ module Ldp
 
         inlinedResources = get.graph.query(:predicate => Ldp.inlinedResource).map { |x| x.object }
 
-        unless inlinedResource.empty?
+        unless inlinedResources.empty?
           new_graph = RDF::Graph.new
 
           original_graph.each_statement do |s|
-            unless inlinedResource.include? s.subject
+            unless inlinedResources.include? s.subject
               new_graph << s
             end
           end
@@ -30,29 +100,31 @@ module Ldp
       end
     end
 
-    def get
-      @get ||= client.get subject
-    end
+    def self.check_for_differences_and_reload_resource old_object
+      new_object = old_object.reload
 
-    def delete
-      client.delete subject do |req|
-        if @get
-          req.headers['If-Match'] << get.headers['ETag']
+      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
 
-      @get = nil
-      @graph = nil
+      diff
     end
 
-    def update
-      client.put subject, graph.dump(:ttl) do |req|
-        if @get
-          req.headers['If-Match'] << get.headers['ETag']
-        end
-      end
-      @get = nil
-      @graph = nil
+    ##
+    # Reload this resource as an LDP container
+    def as_container
+      Ldp::Container.new client, subject, @graph || @get
     end
   end
-end
+end

data/lib/ldp/response.rb

@@ -1,17 +1,22 @@
 module Ldp
   module Response
+
+    ##
+    # 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
     end
 
+    ##
+    # Extract the Link: headers from the HTTP resource
     def self.links raw_resp
-      Array(raw_resp.headers["Link"]).inject({}) do |memo, header|
+      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] ||= []
           memo[v.first.last] << v.first.first
         end
 
@@ -19,25 +24,63 @@ module Ldp
       end
     end
 
+    ##
+    # Is the response an LDP resource?
     def self.resource? raw_resp
-      links(raw_resp).fetch("type", []).include? Ldp.resource
+      links(raw_resp).fetch("type", []).include? Ldp.resource.to_s
+    end
+
+    ##
+    # Is the response an LDP resource?
+    def resource?
+      Ldp::Response.resource?(self)
+    end
+
+    ##
+    # Is the response an LDP container
+    def container?
+      graph.has_statement? RDF::Statement.new(subject, RDF.type, Ldp.container)
     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
+
+    ##
+    # Get the URI to the response
+    def page_subject
+      @page_subject ||= RDF::URI.new env[:url]
+    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
     end
 
+    ##
+    # Get the graph for the resource (or a blank graph if there is no metadata for the resource)
     def graph
       @graph ||= begin
         graph = RDF::Graph.new
 
-        RDF::Reader.for(:ttl).new(StringIO.new(body), :base_uri => subject) do |reader|
-          reader.each_statement do |s|
-            graph << s
+        if resource?
+          RDF::Reader.for(:ttl).new(StringIO.new(body), :base_uri => page_subject) do |reader|
+            reader.each_statement do |s|
+              graph << s
+            end
           end
         end
 
@@ -45,52 +88,90 @@ module Ldp
       end
     end
 
+    ##
+    # Extract the ETag for the resource
     def etag
-
+      headers['ETag']
     end
 
+    ##
+    # Extract the last modified header for the resource
     def last_modified
-
+      headers['Last-Modified']
     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
     end
 
-    def paginated?
+    ##
+    # 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
-
-    end
-
-    def resource?
-      Ldp::Response.resource?(self)
+      graph.query RDF::Statement.new(page_subject, membership_predicate, nil)
     end
 
-    def container?
-      graph.has_statement? RDF::Statement.new(subject, RDF.type, Ldp.container)
+    ##
+    # Predicate to use to determine container membership
+    def membership_predicate
+      graph.first_object [page_subject, Ldp.membership_predicate, nil]
     end
 
     def sort
 
     end
 
-    def subject
-      RDF::URI.new env[:url]
+    ##
+    # Link: headers from the HTTP response
+    def links
+      Ldp::Response.links(self)
     end
   end
 end

data/lib/ldp/uri.rb

@@ -0,0 +1,35 @@
+module Ldp::Uri
+
+  def uri str
+    RDF::URI.new("http://www.w3.org/ns/ldp#") + str
+  end
+
+  def resource
+    uri("Resource")
+  end
+
+  def container
+    uri("Container")
+  end
+
+  def page
+    uri("Page")
+  end
+
+  def page_of
+    uri("pageOf")
+  end
+
+  def next_page
+    uri("nextPage")
+  end
+
+  def inlinedResource
+    uri("inlinedResource")
+  end
+
+  def membership_predicate
+    uri("membershipPredicate")
+  end
+
+end

data/lib/ldp/version.rb

@@ -1,3 +1,3 @@
 module Ldp
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/lib/integration/integration_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe "Integration tests" do
+
+end

data/spec/lib/ldp/client_spec.rb

@@ -6,6 +6,14 @@ describe "Ldp::Client" do
       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)
@@ -13,9 +21,11 @@ describe "Ldp::Client" do
 
     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.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
     end
 
@@ -53,11 +63,69 @@ describe "Ldp::Client" do
       expect(resp.resource?).to be_true
     end
 
-    describe "response" do
+    it "should accept a block to change the HTTP request" do
+      expect { |b| subject.get "a_resource", &b }.to yield_control
+    end
+  end
+
+  describe "delete" do
+    it "should DELETE the subject from the HTTP endpoint" do
+      resp = subject.delete "a_resource"
+      expect(resp.status).to eq(204)
+    end
+
+    it "should accept a block to change the HTTP request" do
+      expect { |b| subject.delete "a_resource", &b }.to yield_control
+    end
+  end
+
+  describe "post" do
+    it "should POST to the subject at the HTTP endpoint" do
+      resp = subject.post "a_container"
+      expect(resp.status).to eq(201)
+      expect(resp.headers[:Location]).to eq("http://example.com/a_container/subresource")
+    end
+
+    it "should set content" do
+      subject.post "a_container", 'foo' do |req|
+        expect(req.body).to eq 'foo'
+      end
+    end
+
+    it "should set default Content-type" do
+      subject.post "a_container", 'foo' do |req|
+        expect(req.headers).to eq({ "Content-Type" => "text/turtle" }) 
+      end
+    end
+
+    it "should set headers" do
+      subject.post "a_container", 'foo', {'Content-Type' => 'application/pdf'} do |req|
+        expect(req.headers).to eq({ "Content-Type" => "application/pdf" }) 
+      end
+    end
+
+    it "should set headers passed as arguments" do
+      resp = subject.post "a_container"
+    end
+
+    it "should accept a block to change the HTTP request" do
+      expect { |b| subject.post "a_container", &b }.to yield_control
+    end
+
+  end
+
+  describe "put" do
+    it "should PUT content to the subject at the HTTP endpoint" do
+      resp = subject.put "a_resource", "some-payload"
+      expect(resp.status).to eq(204)
+    end
 
+    it "should accept a block to change the HTTP request" do
+      expect { |b| subject.put "a_resource", "some-payload", &b }.to yield_control
     end
   end
 
+
   describe "find_or_initialize" do
     it "should be a resource" do
       resource = subject.find_or_initialize "a_resource"
@@ -71,4 +139,4 @@ describe "Ldp::Client" do
     end
 
   end
-end
+end

data/spec/lib/ldp/orm/orm_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe Ldp::Orm do
+  subject { Ldp::Orm.new test_resource }
+  
+  let(:simple_graph) do
+    graph = RDF::Graph.new << [RDF::URI.new(""), RDF::DC.title, "Hello, world!"]
+    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.put("/a_resource") { [204]}
+    end
+  end
+
+  let(:mock_conn) do
+    test = Faraday.new do |builder|
+      builder.adapter :test, conn_stubs do |stub|
+      end
+    end
+  end
+
+  let :mock_client do
+    Ldp::Client.new mock_conn
+  end
+
+  let :test_resource do
+    Ldp::Resource.new mock_client, "http://example.com/a_resource"
+  end
+
+  describe "#delete" do
+    it "should delete the LDP resource" do
+      test_resource.should_receive(:delete)
+      subject.delete
+    end
+  end
+
+  describe "#create" do
+
+  end
+
+  describe "#save" do
+    it "should update the resource from the graph" do
+      expect(subject.save).to be_true
+    end
+
+    it "should provide a graph of differences if the post-save graph doesn't match our graph" do
+      subject.graph << RDF::Statement.new(:subject => subject.resource.subject_uri, :predicate => RDF::URI.new("info:some-predicate"), :object => RDF::Literal.new("xyz"))
+      result = subject.save
+      expect(result).to_not be_empty
+    end
+
+    it "should return false if the response was not successful" do
+      conn_stubs.instance_variable_get(:@stack)[:put] = [] # erases the stubs for :put
+      conn_stubs.put('/a_resource') {[412]}
+      expect(subject.save).to be_false
+    end
+  end
+
+  describe "#save!" do
+    it "should raise an exception if there are differences after saving the graph" do
+      subject.graph << RDF::Statement.new(:subject => subject.resource.subject_uri, :predicate => RDF::URI.new("info:some-predicate"), :object => RDF::Literal.new("xyz"))
+      expect { subject.save! }.to raise_exception(Ldp::GraphDifferenceException)
+    end
+
+    it "should raise an exception if the ETag didn't match" do
+      conn_stubs.instance_variable_get(:@stack)[:put] = [] # erases the stubs for :put
+      conn_stubs.put('/a_resource') {[412, {}, "Bad If-Match header value: 'ae43aa934dc4f4e15ea1b4dd1ca7a56791972836'"]}
+      expect { subject.save! }.to raise_exception(Ldp::SaveException)
+    end
+  end
+
+  describe "#value" do
+    it "should provide a convenience method for retrieving values" do
+      expect(subject.value(RDF::DC.title).first.to_s).to eq "Hello, world!"
+    end
+  end
+
+  describe "#reload" do
+    before do
+      updated_graph = RDF::Graph.new << [RDF::URI.new(""), RDF::DC.title, "Hello again, world!"]
+      conn_stubs.get('/a_resource') {[200,
+                                      {"Link" => "http://www.w3.org/ns/ldp#Resource;rel=\"type\"",
+                                       "ETag" => "new-tag"},
+                                      updated_graph.dump(:ttl)]}
+    end
+
+    it "loads the new values" do
+      old_value = subject.value(RDF::DC.title).first.to_s
+      reloaded = subject.reload
+      expect(reloaded.value(RDF::DC.title).first.to_s).not_to eq old_value
+    end
+
+    it "uses the new ETag" do
+      old_tag = subject.resource.get.etag
+      reloaded = subject.reload
+      expect(reloaded.resource.get.etag).not_to eq old_tag
+    end
+  end
+end

data/spec/lib/ldp/resource_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Ldp::Resource do
+  subject { Ldp::Resource.new(mock_client, path) }
+
+  let(:conn_stubs) do
+    stubs = Faraday::Adapter::Test::Stubs.new do |stub|
+      stub.get('/not_found_resource') { [404] }
+      stub.get('/a_resource') { [200] }
+    end
+  end
+
+  let(:mock_conn) do
+    test = Faraday.new do |builder|
+      builder.adapter :test, conn_stubs do |stub|
+      end
+    end
+  end
+
+  let :mock_client do
+    Ldp::Client.new mock_conn
+  end
+
+  describe "#get" do
+    context "when the resource is not in repository" do
+      let(:path) { '/not_found_resource' }
+      it "should raise an error" do
+        expect{ subject.get }.to raise_error Ldp::NotFound
+      end
+    end
+
+    context "when the resource is in the repository" do
+      let(:path) { '/a_resource' }
+      it "should get the response" do
+        expect(subject.get).to be_kind_of Faraday::Response
+        expect(subject.get.status).to eq 200
+      end
+    end
+  end
+end

data/spec/lib/ldp/response_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe Ldp::Response do
+  LDP_RESOURCE_HEADERS = { "Link" => Ldp.resource.to_s + ";rel=\"type\""}
+
+  let(:mock_response) { double() }
+  let(:mock_client) { double(Ldp::Client) }
+
+  subject do
+    Ldp::Response.wrap mock_client, mock_response
+  end
+
+  describe ".wrap" do
+    it "should mixin Ldp::Response into the raw response" do
+      Ldp::Response.wrap(mock_client, mock_response)
+      expect(mock_response).to be_a_kind_of(Ldp::Response)
+      expect(mock_response.ldp_client).to eq(mock_client)
+    end
+  end
+
+  describe ".links" do
+    it "should extract link headers with relations as a hash" do
+      mock_response.stub(:headers => { 
+        "Link" => [
+            "xyz;rel=\"some-rel\"",
+            "abc;rel=\"some-multi-rel\"",
+            "123;rel=\"some-multi-rel\"",
+            "vanilla-link"
+          ] 
+        })
+      h = Ldp::Response.links mock_response
+
+      expect(h['some-rel']).to include("xyz")
+      expect(h['some-multi-rel']).to include("abc", "123")
+      expect(h['doesnt-exist']).to be_empty
+    end
+
+    it "should return an empty hash if no link headers are availabe" do
+      mock_response.stub(:headers => {})
+      h = Ldp::Response.links mock_response
+
+      expect(h).to be_empty
+    end
+
+  end
+
+  describe ".resource?" do
+    it "should be a resource if a Link[rel=type] header asserts it is an ldp:resource" do
+      mock_response.stub(:headers => { 
+        "Link" => [
+            "#{Ldp.resource};rel=\"type\""
+          ] 
+      })
+      expect(Ldp::Response.resource? mock_response).to be_true
+    end
+  end
+
+  describe "#graph" do
+    it "should parse the response body for an RDF graph" do
+      mock_response.stub :body => "<> <info:b> <info:c> .", :headers => LDP_RESOURCE_HEADERS
+      subject.stub :page_subject => RDF::URI.new('info:a')
+      graph = subject.graph
+     
+      expect(graph).to have_subject(RDF::URI.new("info:a")) 
+      expect(graph).to have_statement RDF::Statement.new(RDF::URI.new("info:a"), RDF::URI.new("info:b"), RDF::URI.new("info:c"))
+
+    end
+  end
+
+  describe "#etag" do
+    it "should pass through the response's ETag" do
+      mock_response.stub :headers => { 'ETag' => 'xyz'}
+
+      expect(subject.etag).to eq('xyz')
+    end
+  end
+
+  describe "#last_modified" do
+    it "should pass through the response's Last-Modified" do
+      mock_response.stub :headers => { 'Last-Modified' => 'some-date'}
+      expect(subject.last_modified).to eq('some-date')
+    end
+  end
+
+  describe "#has_page" do
+    it "should see if the response has an ldp:Page statement" do
+      graph = RDF::Graph.new
+
+      subject.stub :page_subject => RDF::URI.new('info:a')
+
+      graph << [RDF::URI.new('info:a'), RDF.type, Ldp.page]
+
+      mock_response.stub :body => graph.dump(:ttl), :headers => LDP_RESOURCE_HEADERS
+
+      expect(subject).to have_page
+    end
+
+    it "should be false otherwise" do
+      subject.stub :page_subject => RDF::URI.new('info:a')
+      mock_response.stub :body => '', :headers => LDP_RESOURCE_HEADERS
+      expect(subject).not_to have_page
+    end
+  end
+
+  describe "#page" do
+    it "should get the ldp:Page data from the query" do
+      graph = RDF::Graph.new
+
+      subject.stub :page_subject => RDF::URI.new('info:a')
+
+      graph << [RDF::URI.new('info:a'), RDF.type, Ldp.page]
+      graph << [RDF::URI.new('info:b'), RDF.type, Ldp.page]
+
+      mock_response.stub :body => graph.dump(:ttl), :headers => LDP_RESOURCE_HEADERS
+
+      expect(subject.page.count).to eq(1)
+   
+    end
+  end
+
+  describe "#subject" do
+    it "should extract the HTTP request URI as an RDF URI" do
+      mock_response.stub :body => '', :headers => LDP_RESOURCE_HEADERS
+      mock_response.stub :env => { :url => 'http://xyz/a'}
+      expect(subject.subject).to eq(RDF::URI.new("http://xyz/a"))
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -5,7 +5,6 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'rspec/autorun'
 require 'ldp'
 require 'faraday'
-require "byebug" 
 
 RSpec.configure do |config|
 

metadata

@@ -1,83 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: ldp
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Chris Beer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-31 00:00:00.000000000 Z
+date: 2014-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: linkeddata
   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: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Linked Data Platform client library
@@ -87,7 +87,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -95,11 +96,18 @@ files:
 - ldp.gemspec
 - lib/ldp.rb
 - lib/ldp/client.rb
+- lib/ldp/client/methods.rb
 - lib/ldp/container.rb
+- lib/ldp/orm.rb
 - lib/ldp/resource.rb
 - lib/ldp/response.rb
+- lib/ldp/uri.rb
 - lib/ldp/version.rb
+- spec/lib/integration/integration_spec.rb
 - spec/lib/ldp/client_spec.rb
+- spec/lib/ldp/orm/orm_spec.rb
+- spec/lib/ldp/resource_spec.rb
+- spec/lib/ldp/response_spec.rb
 - spec/spec_helper.rb
 homepage: ''
 licenses:
@@ -111,20 +119,25 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Linked Data Platform client library
 test_files:
+- spec/lib/integration/integration_spec.rb
 - spec/lib/ldp/client_spec.rb
+- spec/lib/ldp/orm/orm_spec.rb
+- spec/lib/ldp/resource_spec.rb
+- spec/lib/ldp/response_spec.rb
 - spec/spec_helper.rb
+has_rdoc: