ldp 0.4.1 → 0.5.0

data/lib/ldp/resource/rdf_source.rb

@@ -28,7 +28,7 @@ module Ldp
     end
 
     def graph
-      @graph ||= new? ? build_empty_graph : build_graph(response_as_graph(get))
+      @graph ||= new? ? build_empty_graph : filtered_graph(response_graph)
     end
 
     def build_empty_graph
@@ -38,34 +38,49 @@ module Ldp
     ##
     # graph_class may be overridden so that a subclass of RDF::Graph
     # is returned (e.g. an ActiveTriples resource)
-    # @returns [Class] a class that is an descendant of RDF::Graph
+    # @return [Class] a class that is an descendant of RDF::Graph
     def graph_class
       RDF::Graph
     end
 
+    ##
+    # Parse the graph returned by the LDP server into an RDF::Graph
+    # @return [RDF::Graph]
+    def response_graph
+      @response_graph ||= response_as_graph(get)
+    end
+
+    # Get the body and ensure it's UTF-8 encoded. Since Fedora 9.3 isn't
+    # returning a charset, then Net::HTTP is just returning ASCII-8BIT
+    # See https://github.com/ruby-rdf/rdf-turtle/issues/13
+    # See https://jira.duraspace.org/browse/FCREPO-1750
+    def body
+      body.force_encoding('utf-8')
+    end
 
+    protected
+
+    def interaction_model
+      RDF::Vocab::LDP.Resource unless client.options[:omit_ldpr_interaction_model]
+    end
 
     private
       ##
       # @param [Faraday::Response] graph query response
       # @return [RDF::Graph]
       def response_as_graph(resp)
-        content_type = resp.headers['Content-Type'] || 'text/turtle'
-        content_type = Array(content_type).first
-        format = Array(RDF::Format.content_types[content_type]).first
-        source = resp.body
-        reader = RDF::Reader.for(content_type:content_type).new(source, base_uri:subject)
         graph = build_empty_graph
-        reader.each_statement do |stmt|
+        resp.each_statement do |stmt|
           graph << stmt
         end
         graph
       end
+
       ##
       # @param [RDF::Graph] original_graph The graph returned by the LDP server
-      # @return [RDF::Graph] A graph striped of any inlined resources present in the original
-      def build_graph(original_graph)
-        inlined_resources = response_as_graph(get).query(predicate: Ldp.contains).map { |x| x.object }
+      # @return [RDF::Graph] A graph stripped of any inlined resources present in the original
+      def filtered_graph(original_graph)
+        inlined_resources = original_graph.query(predicate: RDF::Vocab::LDP.contains).map { |x| x.object }
 
         # we want to scope this graph to just statements about this model, not contained relations
         if inlined_resources.empty?

data/lib/ldp/response.rb

@@ -1,35 +1,40 @@
+require 'uri'
+
 module Ldp
-  module Response
-    require 'ldp/response/paging'
+  class Response
+    extend Forwardable
 
     TYPE = 'type'.freeze
-    ##
-    # Wrap the raw Faraday respone with our LDP extensions
-    def self.wrap client, raw_resp
-      raw_resp.send(:extend, Ldp::Response)
-      raw_resp.send(:extend, Ldp::Response::Paging) if raw_resp.has_page?
-      raw_resp
+
+    attr_reader :response
+
+    attr_writer :etag, :last_modified
+
+    def initialize(response)
+      @response = response
     end
 
     ##
     # Extract the Link: headers from the HTTP resource
-    def self.links response
-      h = {}
-      Array(response.headers['Link'.freeze]).map { |x| x.split(', '.freeze) }.flatten.inject(h) do |memo, header|
-        m = header.match(/<(?<link>.*)>;\s?rel="(?<rel>[^"]+)"/)
-        if m
-          memo[m[:rel]] ||= []
-          memo[m[:rel]] << m[:link]
-        end
+    def links
+      @links ||= begin
+        h = {}
+        Array(headers['Link'.freeze]).map { |x| x.split(','.freeze) }.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
+          memo
+        end
       end
     end
 
-    def self.applied_preferences headers
+    def applied_preferences
       h = {}
 
-      Array(headers).map { |x| x.split(",") }.flatten.inject(h) do |memo, header|
+      Array(headers['Preference-Applied'.freeze]).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(" ")
@@ -40,101 +45,78 @@ module Ldp
     ##
     # Is the response an LDP resource?
 
-    def self.resource? response
-      Array(links(response)[TYPE]).include? Ldp.resource.to_s
+    def resource?
+      Array(links[TYPE]).include? RDF::Vocab::LDP.Resource.to_s
     end
 
     ##
     # Is the response an LDP container?
-    def self.container? response
+    def container?
       [
-        Ldp.basic_container,
-        Ldp.direct_container,
-        Ldp.indirect_container
-      ].any? { |x| Array(links(response)[TYPE]).include? x.to_s }
+        RDF::Vocab::LDP.BasicContainer,
+        RDF::Vocab::LDP.DirectContainer,
+        RDF::Vocab::LDP.IndirectContainer
+      ].any? { |x| Array(links[TYPE]).include? x.to_s }
     end
 
     ##
     # Is the response an LDP RDFSource?
     #   ldp:Container is a subclass of ldp:RDFSource
-    def self.rdf_source? response
-      container?(response) || Array(links(response)[TYPE]).include?(Ldp.rdf_source)
+    def rdf_source?
+      container? || Array(links[TYPE]).include?(RDF::Vocab::LDP.RDFSource)
     end
 
     def dup
       super.tap do |new_resp|
-        new_resp.send(:extend, Ldp::Response)
         unless new_resp.instance_variable_get(:@graph).nil?
-          if ::RUBY_VERSION < '2.0'
-            new_resp.send(:remove_instance_variable, :@graph)
-          else
-            new_resp.remove_instance_variable(:@graph)
-          end
+          new_resp.remove_instance_variable(:@graph)
         end
       end
     end
 
-    ##
-    # Link: headers from the HTTP response
-    def links
-      @links ||= Ldp::Response.links(self)
-    end
-
-    ##
-    # Is the response an LDP resource?
-    def resource?
-      Ldp::Response.resource?(self)
-    end
-
-    ##
-    # Is the response an LDP rdf source?
-    def rdf_source?
-      Ldp::Response.rdf_source?(self)
-    end
-
-    ##
-    # Is the response an LDP container
-    def container?
-      Ldp::Response.container?(self)
-    end
-
-    def preferences
-      Ldp::Resource.applied_preferences(headers['Preference-Applied'.freeze])
-    end
     ##
     # Get the subject for the response
     def subject
-      page_subject
+      @subject ||= if has_page?
+        graph.first_object [page_subject, RDF::Vocab::LDP.pageOf, nil]
+      else
+        page_subject
+      end
     end
 
     ##
     # Get the URI to the response
     def page_subject
-      @page_subject ||= RDF::URI.new env[:url]
+      @page_subject ||= RDF::URI.new response.env[:url]
     end
 
     ##
     # Is the response paginated?
     def has_page?
-      rdf_source? && graph.has_statement?(RDF::Statement.new(page_subject, RDF.type, Ldp.page))
+      rdf_source? && graph.has_statement?(RDF::Statement.new(page_subject, RDF.type, RDF::Vocab::LDP.Page))
+    end
+
+    def body
+      response.body
     end
 
     ##
     # Get the graph for the resource (or a blank graph if there is no metadata for the resource)
     def graph
       @graph ||= begin
-        raise UnexpectedContentType, "The resource at #{page_subject} is not an RDFSource" unless rdf_source?
         graph = RDF::Graph.new
+        each_statement { |s| graph << s }
+        graph
+      end
+    end
 
-        if resource?
-          RDF::Reader.for(:ttl).new(response_body, base_uri: page_subject) do |reader|
-            reader.each_statement do |s|
-              graph << s
-            end
-          end
-        end
+    def reader(&block)
+      reader_for_content_type.new(body, base_uri: page_subject, &block)
+    end
 
-        graph
+    def each_statement(&block)
+      reader do |reader|
+        reader.each_statement(&block)
       end
     end
 
@@ -144,20 +126,12 @@ module Ldp
       @etag ||= headers['ETag'.freeze]
     end
 
-    def etag=(val)
-      @etag = val
-    end
-
     ##
     # Extract the last modified header for the resource
     def last_modified
       @last_modified ||= headers['Last-Modified'.freeze]
     end
 
-    def last_modified=(val)
-      @last_modified = val
-    end
-
     ##
     # Extract the Link: rel="type" headers for the resource
     def types
@@ -176,14 +150,69 @@ module Ldp
       preferences[RETURN][:value] == "minimal"
     end
 
-    private
+    ##
+    # 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
+
+    ##
+    # 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, RDF::Vocab::LDP.nextPage, nil]
+    end
 
-      # Get the body and ensure it's UTF-8 encoded. Since Fedora 9.3 isn't
-      # returning a charset, then Net::HTTP is just returning ASCII-8BIT
-      # See https://github.com/ruby-rdf/rdf-turtle/issues/13
-      # See https://jira.duraspace.org/browse/FCREPO-1750
-      def response_body
-        body.force_encoding('utf-8')
+    ##
+    # 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, RDF::Vocab::LDP.nextPage, nil)
+        subject
       end
+    end
+
+    def content_type
+      headers['Content-Type']
+    end
+
+    def content_length
+      headers['Content-Length'].to_i
+    end
+
+    def content_disposition_filename
+      m = headers['Content-Disposition'].match(/filename="(?<filename>[^"]*)";/)
+      URI.decode(m[:filename]) if m
+    end
+
+    private
+
+    def headers
+      response.headers
+    end
+
+    def reader_for_content_type
+      content_type = content_type || 'text/turtle'
+      content_type = Array(content_type).first
+      RDF::Reader.for(content_type: content_type)
+    end
   end
 end

data/lib/ldp/uri.rb

@@ -1,75 +1,91 @@
 module Ldp::Uri
+  extend Deprecation
+  self.deprecation_horizon = 'ldp version 0.6'
 
   def uri str
     RDF::URI.new("http://www.w3.org/ns/ldp#") + str
   end
+  deprecation_deprecate :uri
 
   def resource
-    uri("Resource")
+    RDF::Vocab::LDP.Resource
   end
+  deprecation_deprecate :resource
 
   def rdf_source
-    uri("RDFSource")
+    RDF::Vocab::LDP.RDFSource
   end
+  deprecation_deprecate :rdf_source
 
   def non_rdf_source
-    uri("NonRDFSource")
+    RDF::Vocab::LDP.NonRDFSource
   end
+  deprecation_deprecate :non_rdf_source
 
   def container
-    uri("Container")
+    RDF::Vocab::LDP.Container
   end
+  deprecation_deprecate :container
 
   def basic_container
-    uri("BasicContainer")
+    RDF::Vocab::LDP.BasicContainer
   end
+  deprecation_deprecate :basic_container
 
   def direct_container
-    uri("DirectContainer")
+    RDF::Vocab::LDP.DirectContainer
   end
+  deprecation_deprecate :direct_container
 
   def indirect_container
-    uri("IndirectContainer")
+    RDF::Vocab::LDP.IndirectContainer
   end
+  deprecation_deprecate :indirect_container
 
   def contains
-    uri("contains")
+    RDF::Vocab::LDP.contains
   end
+  deprecation_deprecate :contains
 
   def page
-    uri("Page")
+    RDF::Vocab::LDP.Page
   end
+  deprecation_deprecate :page
 
   def page_of
-    uri("pageOf")
+    RDF::Vocab::LDP.pageOf
   end
+  deprecation_deprecate :page_of
 
   def next_page
-    uri("nextPage")
+    RDF::Vocab::LDP.nextPage
   end
+  deprecation_deprecate :next_page
 
   def membership_predicate
-    uri("membershipPredicate")
+    RDF::Vocab::LDP.membershipPredicate
   end
-  
+  deprecation_deprecate :membership_predicate
+
   def prefer_empty_container
-    uri("PreferEmptyContainer")
+    RDF::Vocab::LDP.PreferEmptyContainer
   end
-  
+
   def prefer_membership
-    uri("PreferMembership")
+    RDF::Vocab::LDP.PreferMembership
   end
-  
+
   def prefer_containment
-    uri("PreferContainment")
+    RDF::Vocab::LDP.PreferContainment
   end
-  
+
   def has_member_relation
-    uri("hasMemberRelation")
+    RDF::Vocab::LDP.hasMemberRelation
   end
-  
+  deprecation_deprecate :has_member_relation
+
   def member
-    uri("member")
+    RDF::Vocab::LDP.member
   end
-
+  deprecation_deprecate :member
 end