ldp 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8ea0daaba00e2614ee8dc9597db049fb7081e3ae
-  data.tar.gz: e15f930db252d3dbe6fc03a638f29d703ea53da1
+  metadata.gz: b564742703ded9a1ea57b61c4d35095152470b0d
+  data.tar.gz: 92c8f28addad7872849b36acfdeac29bb2ebf280
 SHA512:
-  metadata.gz: 976bd681a8322b5c1a1780b27caf56dd5e65cc09420fea41a2db234fec392c4d63c4ad3eb1f2272c87b9b49927af2bfd98931f60ec1bd623d9b970183a6db2b4
-  data.tar.gz: 9de1c9c88954f66e2856cbf6c10a6624396667bb1f5efda080c983d40e382ef855ab42e39372c65c45417221ee1d0d069a52d2444f05e4545d107f10d172503d
+  metadata.gz: c47ff6ed7653614374db095e93defbfa21138b072862de841464c06b8c0494707ee5d39610d06bdb640d8b4214590aae81de5f264ccbb61349afe2ffffaeb594
+  data.tar.gz: 2ad220371ea1d981c8ab3d29aca7f615e0bf573d56da2c56de84ba0d15a23a1173638eba23e97ef38d09eab26a7cef398037113453b017a8ffe5b01c138b25aa

data/Gemfile

@@ -4,4 +4,4 @@ source 'https://rubygems.org'
 gemspec
 
 gem 'byebug', :platforms => [:mri_20]
-
+gem 'activesupport'

data/bin/ldp

@@ -0,0 +1,127 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'ldp'
+require 'slop'
+
+HttpLogger.logger = Logger.new(STDERR)
+HttpLogger.log_headers = true
+
+def with_error_handling
+  yield
+rescue Ldp::NotFound
+  exit 1
+end
+
+do_help = lambda do |x|
+
+  x.command 'help' do
+    run do |opts, args|
+      puts opts.help
+    end
+  end
+
+end
+
+Slop.parse do
+  banner "Usage: ldp [command] --host [HOST] [options]"
+
+  on '-v', 'Print the version' do
+    puts "ldp #{Ldp::VERSION}"
+  end
+
+  on :host=, "Host"
+  
+  do_help.call(self)
+
+  command 'get' do
+    banner "Usage: ldp get --host [HOST] [PATH]"
+
+    on :host=, "Host"
+
+    do_help.call(self)
+
+    run do |opts, (path)|
+      with_error_handling do
+        host = opts[:host] || ENV['LDP_HOST']
+        puts Ldp::Client.new(url: host).find_or_initialize(path).get.body
+      end
+    end
+  end
+
+  command 'delete' do
+    banner "Usage: ldp delete --host [HOST] [PATH]"
+
+    on :host=, "Host"
+    do_help.call(self)
+
+    run do |opts, (path)|
+      with_error_handling do
+        host = opts[:host] || ENV['LDP_HOST']
+        Ldp::Client.new(url: host).delete path
+      end
+    end
+  end
+
+  command 'create' do
+    banner "Usage: ldp create --host [HOST] [PATH] [SOURCE]"
+
+    on :host=, "Host"
+    do_help.call(self)
+
+    run do |opts, (path, file)|
+      with_error_handling do
+        host = opts[:host] || ENV['LDP_HOST']
+        if file.nil?
+          Ldp::Client.new(url: host).post path
+        elsif file == "-"
+          Ldp::Client.new(url: host).post path, $stdin
+        else
+          Ldp::Client.new(url: host).post path, File.read(file)
+        end
+      end
+    end
+  end
+
+  command 'replace' do
+    banner "Usage: ldp replace --host [HOST] [PATH] [SOURCE]"
+
+    on :host=, "Host"
+    do_help.call(self)
+
+    run do |opts, (path,file)|
+      with_error_handling do
+        host = opts[:host] || ENV['LDP_HOST']
+        if file.nil?
+          Ldp::Client.new(url: host).put path
+        elsif file == "-"
+          Ldp::Client.new(url: host).put path, $stdin
+        else
+          Ldp::Client.new(url: host).put path, File.read(file)
+        end
+      end
+    end
+  end
+
+  command 'patch' do
+    banner "Usage: ldp patch --host [HOST] [PATH] [SOURCE]"
+
+    on :host=, "Host"
+    do_help.call(self)
+
+    run do |opts, (path,file)|
+      with_error_handling do
+        host = opts[:host] || ENV['LDP_HOST']
+        if file.nil?
+          Ldp::Client.new(url: host).patch path
+        elsif file == "-"
+          Ldp::Client.new(url: host).patch path, $stdin.read
+        else
+          Ldp::Client.new(url: host).patch path, File.read(file)
+        end
+      end
+    end
+  end
+end

data/ldp.gemspec

@@ -20,6 +20,8 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "faraday"
   spec.add_dependency "linkeddata", ">= 1.1"
+  spec.add_dependency "http_logger"
+  spec.add_dependency "slop"
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"

data/lib/ldp/client/methods.rb

@@ -1,12 +1,46 @@
+require 'faraday'
+
+##
+# HTTP client methods for making requests to an LDP resource and getting a response back.
 module Ldp::Client::Methods
-  def logger
-    Ldp.logger
+  
+  attr_reader :http
+  def initialize_http_client *http_client
+    if http_client.length == 1 and http_client.first.is_a? Faraday::Connection
+      @http = http_client.first
+    else 
+      @http = Faraday.new *http_client  
+    end
+  end
+  
+  def head url
+    logger.debug "LDP: HEAD [#{url}]"
+    resp = http.head do |req|                          
+      req.url munge_to_relative_url(url)
+
+      yield req if block_given?
+    end
+
+    check_for_errors(resp)
   end
 
   # Get a LDP Resource by URI
-  def get url
+  def get url, options = {}
+    logger.debug "LDP: GET [#{url}]"
     resp = http.get do |req|                          
-      req.url url
+      req.url munge_to_relative_url(url)
+
+      if options[:minimal]
+        req.headers["Prefer"] = "return=minimal"
+      else
+        includes = Array(options[:include]).map { |x| Ldp.send("prefer_#{x}") if Ldp.respond_to? "prefer_#{x}" }
+        omits = Array(options[:omit]).map { |x| Ldp.send("prefer_#{x}") if Ldp.respond_to? "prefer_#{x}" }
+        req.headers["Prefer"] = ["return=representation", 
+          ("include=\"#{includes.join(" ")}\"" unless includes.empty?),
+          ("omit=\"#{omits.join(" ")}\"" unless omits.empty?)
+        ].compact.join("; ")
+      end
+
       yield req if block_given?
     end
 
@@ -15,41 +49,84 @@ module Ldp::Client::Methods
     else
       resp
     end
+    
+    check_for_errors(resp)
   end
 
   # Delete a LDP Resource by URI
   def delete url
-    http.delete do |req|
-      req.url url
+    logger.debug "LDP: DELETE [#{url}]"
+    resp = http.delete do |req|
+      req.url munge_to_relative_url(url)
       yield req if block_given?
     end
+
+    check_for_errors(resp)
   end
 
   # Post TTL to an LDP Resource
   def post url, body = nil, headers = {}
-    logger.debug "POST [#{url}] #{body}"
-    http.post do |req|
-      req.url url
+    logger.debug "LDP: POST [#{url}]"
+    resp = http.post do |req|
+      req.url munge_to_relative_url(url)
       req.headers = default_headers.merge headers
       req.body = body
       yield req if block_given?
     end
+    check_for_errors(resp)
   end
 
   # Update an LDP resource with TTL by URI
   def put url, body, headers = {}
-    logger.debug "PUT [#{url}] #{body}"
-    http.put do |req|
-      req.url url
+    logger.debug "LDP: PUT [#{url}]"
+    resp = http.put do |req|
+      req.url munge_to_relative_url(url)
       req.headers = default_headers.merge headers
       req.body = body
       yield req if block_given?
     end
+    check_for_errors(resp)
   end
 
+  # Update an LDP resource with TTL by URI
+  def patch url, body, headers = {}
+    logger.debug "LDP: PATCH [#{url}]"
+    resp = http.patch do |req|
+      req.url munge_to_relative_url(url)
+      req.headers = default_patch_headers.merge headers
+      req.body = body
+      yield req if block_given?
+    end
+    check_for_errors(resp)
+  end
   private
+  
+  def check_for_errors resp
+    resp.tap do |resp|
+      unless resp.success?
+        raise Ldp::NotFound.new(resp.body) if resp.status == 404
+        raise Ldp::HttpError.new("STATUS: #{resp.status} #{resp.body[0, 1000]}...")
+      end
+    end
+  end
 
   def default_headers
     {"Content-Type"=>"text/turtle"}
   end
+  
+  def default_patch_headers
+    {"Content-Type"=>"application/sparql-update"}
+  end
+  ##
+  # Some valid query paths can be mistaken for absolute URIs
+  # with an alternative scheme. If the scheme isn't HTTP(S), assume
+  # they meant a relative URI instead. 
+  def munge_to_relative_url url
+    purl = URI.parse(url)
+    if purl.absolute? and !((purl.scheme rescue nil) =~ /^http/)
+      "./" + url
+    else
+      url
+    end
+  end
 end

data/lib/ldp/client.rb

@@ -1,36 +1,33 @@
-require 'faraday'
-
+##
+# LDP client for presenting an ORM on top of an LDP resource
 module Ldp
   class Client
 
     require 'ldp/client/methods'
-
     include Ldp::Client::Methods
-    
-    attr_reader :http
 
     def initialize *http_client
-      if http_client.length == 1 and http_client.first.is_a? Faraday::Connection
-        @http = http_client.first
-      else 
-        @http = Faraday.new *http_client  
-      end
+      initialize_http_client *http_client
     end
 
     # Find or initialize a new LDP resource by URI
-    def find_or_initialize subject
-      data = get(subject)
-
-      unless data.is_a? Response
-        raise "#{subject} is not an LDP Resource"
-      end
-
-      if data.container?
-        Container.new self, subject, data
-      else  
-        Resource.new self, subject, data
+    def find_or_initialize subject, options = {}
+      data = get(subject, options = {})
+
+      case
+      when !data.is_a?(Ldp::Response)
+        Resource::BinarySource.new self, subject, data
+      when data.container?
+        Ldp::Container.new_from_response self, subject, data
+      when data.resource?
+        Resource::RdfSource.new self, subject, data
+      else
+        Resource::BinarySource.new self, subject, data
       end
     end
 
+    def logger
+      Ldp.logger
+    end
   end
 end

data/lib/ldp/container/basic.rb

@@ -0,0 +1,23 @@
+module Ldp
+  class Container::Basic < Container
+    def members
+      return enum_for(:members) unless block_given?
+      contains.each { |k, x| yield x }
+    end
+
+    def contains
+      @contains ||= Hash[get.graph.query(predicate: Ldp.contains).map do |x| 
+        [x.object, Ldp::Resource::RdfSource.new(client, x.object, contained_graph(x.object))]
+      end]
+    end
+    
+    private
+    def contained_graph subject
+      g = RDF::Graph.new
+      get.graph.query(subject: subject) do |stmt|
+        g << stmt
+      end
+      g
+    end
+  end
+end

data/lib/ldp/container/direct.rb

@@ -0,0 +1,16 @@
+module Ldp
+  class Container::Direct < Container::Basic
+    def members
+      return enum_for(:members) unless block_given?
+      
+      get.graph.query(subject: subject, predicate: member_relation).map do |x| 
+        yield contains[x.object] || Ldp::Resource::RdfSource.new(client, x.object)
+      end
+    end
+    
+    def member_relation
+      graph.first_object(predicate: Ldp.hasMemberRelation) || Ldp.member
+    end
+    
+  end
+end

data/lib/ldp/container/indirect.rb

@@ -0,0 +1,11 @@
+module Ldp
+  class Container::Indirect < Container::Direct
+    def members
+      return enum_for(:members) unless block_given?
+      
+      get.graph.query(predicate: member_relation, object: subject).map do |x| 
+        yield contains[x.object] || Ldp::Resource::RdfSource.new(client, x.object)
+      end
+    end
+  end
+end

data/lib/ldp/container.rb

@@ -1,7 +1,22 @@
 module Ldp
-  class Container < Resource
+  class Container < Resource::RdfSource
+    require 'ldp/container/basic'
+    require 'ldp/container/direct'
+    require 'ldp/container/indirect'
+
+    def self.new_from_response client, subject, data
+      case
+      when data.types.include?(Ldp.indirect_container)
+        Ldp::Container::Indirect.new client, subject, data
+      when data.types.include?(Ldp.direct_container)
+        Ldp::Container::Direct.new client, subject, data
+      else
+        Ldp::Container::Basic.new client, subject, data
+      end
+    end
+
     ##
-    # Add a resource to the LDP container
+    # Add a new resource to the LDP container
     def add *args
       # slug, graph
       # graph
@@ -11,21 +26,20 @@ module Ldp
       when (args.length > 2 || args.length == 0)
 
       when (args.length == 2)
-        slug, graph = args
+        slug, graph_or_content = args
       when (args.first.is_a? RDF::Graph)
         slug = nil
-        graph = args.first
+        graph_or_content = args.first
       else
         slug = args.first
-        graph = RDF::Graph.new
+        graph_or_content = RDF::Graph.new
       end
 
-      resp = client.post subject, graph.dump(:ttl) do |req|
+      resp = client.post subject, (graph_or_content.is_a?(RDF::Graph) ? graph_or_content.dump(:ttl) : graph_or_content) do |req|
         req.headers['Slug'] = slug
       end
 
-      subject = resp.headers['Location']
-      return client.find_or_initialize subject
+      client.find_or_initialize resp.headers['Location']
     end
   end
-end
+end

data/lib/ldp/orm.rb

@@ -7,39 +7,67 @@ module Ldp
     def initialize resource
       @resource = resource
     end
+    
+    def subject_uri
+      resource.subject_uri
+    end
+    
+    def new?
+      resource.new?
+    end
+    
+    def persisted?
+      !new?
+    end
 
     def graph
-      resource.graph
+      Ldp.instrument 'graph.orm.ldp', subject: subject_uri do
+        resource.graph
+      end
     end
 
     def value predicate
-      graph.query(:subject => resource.subject_uri, :predicate => predicate).map do |stmt|
+      graph.query(:subject => subject_uri, :predicate => predicate).map do |stmt|
         stmt.object
       end
     end
 
     def query *args, &block
-      graph.query *args, &block
+      Ldp.instrument 'query.orm.ldp', subject: subject_uri do
+        graph.query *args, &block
+      end
     end
 
     def reload
-      Ldp::Orm.new resource.reload
+      Ldp.instrument 'reload.orm.ldp', subject: subject_uri do
+        Ldp::Orm.new resource.reload
+      end
     end
 
     def create
-      nil
+      Ldp.instrument 'create.orm.ldp', subject: subject_uri do
+        # resource.create returns a reloaded resource which causes any default URIs (e.g. "<>")
+        # in the graph to be transformed to routable URIs
+        Ldp::Orm.new resource.create
+      end
     end
 
     def save
-      @last_response = resource.update
+      Ldp.instrument 'save.orm.ldp', subject: subject_uri do
+        @last_response = resource.save
 
-      diff = Ldp::Resource.check_for_differences_and_reload_resource self
+        diff = resource.check_for_differences_and_reload
 
-      if diff.any?
-        diff
-      else
-        @last_response.success?
+        if diff.any?
+          diff
+        else
+          @last_response.success?
+        end
       end
+    rescue Ldp::HttpError => e
+      @last_response = e
+      logger.debug e
+      false
     end
 
     def save!
@@ -48,14 +76,16 @@ module Ldp
       if result.is_a? RDF::Graph
         raise GraphDifferenceException.new "", result
       elsif !result
-        raise SaveException.new "", @last_response
+        raise SaveException.new @last_response
       end
 
       result
     end
 
     def delete
-      resource.delete
+      Ldp.instrument 'delete.orm.ldp', subject: subject_uri do
+        resource.delete
+      end
     end
 
     def method_missing meth, *args, &block
@@ -66,6 +96,11 @@ module Ldp
       super
     end
 
+    private
+
+    def logger
+      Ldp.logger
+    end
   end
 
   class GraphDifferenceException < Exception
@@ -76,12 +111,6 @@ module Ldp
     end
   end
 
-  class SaveException < Exception
-    attr_reader :response
-    def initialize message, response
-      super(message)
-      @response = response
-    end
+  class SaveException < RuntimeError
   end
 end
-

data/lib/ldp/resource/binary_source.rb

@@ -0,0 +1,23 @@
+module Ldp
+  class Resource::BinarySource < Ldp::Resource
+    attr_accessor :content
+
+    def initialize client, subject, content_or_response = nil
+      super client, subject, content_or_response
+      
+      case content_or_response
+      when Faraday::Response
+      else
+        @content = content_or_response
+      end
+    end
+    
+    def content
+      @content ||= get.body
+    end
+    
+    def described_by
+      client.find_or_initialize Array(Ldp::Response.links(self)["describedby"]).first
+    end
+  end
+end

data/lib/ldp/resource/rdf_source.rb

@@ -0,0 +1,77 @@
+module Ldp
+  class Resource::RdfSource < Ldp::Resource
+
+    def initialize client, subject, graph_or_response = nil
+      super client, subject, graph_or_response
+
+      case graph_or_response
+        when RDF::Graph
+          @graph = graph_or_response
+        when Ldp::Response
+        when NilClass
+          #nop
+        else
+          raise ArgumentError, "Third argument to #{self.class}.new should be a RDF::Graph or a Ldp::Response. You provided #{graph_or_response.class}"
+      end
+    end
+    
+    def create
+      super do |req|
+        req.headers = { "Content-Type" => "text/turtle" }
+      end
+    end
+    
+    def content
+      graph.dump(:ttl) if graph
+    end
+
+    def graph
+      @graph ||= RDF::Graph.new if new?
+      @graph ||= begin
+        original_graph = get.graph
+
+        inlinedResources = get.graph.query(:predicate => Ldp.contains).map { |x| x.object }
+
+        # we want to scope this graph to just statements about this model, not contained relations
+        unless inlinedResources.empty?
+          new_graph = RDF::Graph.new
+
+          original_graph.each_statement do |s|
+            unless inlinedResources.include? s.subject
+              new_graph << s
+            end
+          end
+
+          new_graph
+        else
+          original_graph
+        end
+      end
+    end
+
+    def check_for_differences_and_reload
+      self.class.check_for_differences_and_reload_resource self
+    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
+  end
+end