roadforest 0.0.1 → 0.0.2

data/examples/file-management.rb

@@ -56,6 +56,7 @@ module FileManagementExample
         end
 
         def add_child(graph)
+          services.logger.debug(graph.source_graph.dump(:nquads))
           new_file = FileRecord.new(graph.first(:lc, "name"), false)
           services.file_records << new_file
         end
@@ -83,7 +84,7 @@ module FileManagementExample
         end
 
         def graph_update(graph)
-          data.resolved = graph[[:lc, "resolved"]]
+          data.resolved = graph[:lc, "resolved"]
           new_graph
         end
 

data/lib/roadforest/application/dispatcher.rb

@@ -7,8 +7,9 @@ module RoadForest
       super(method(:create_resource))
       @services = services
       @route_names = {}
+      @trace_by_default = false
     end
-    attr_accessor :services
+    attr_accessor :services, :trace_by_default
 
     def resource_route(resource, name, path_spec, bindings)
       route = Route.new(path_spec, resource, bindings || {})
@@ -19,10 +20,19 @@ module RoadForest
     end
 
     def add_route(name, path_spec, resource_type, model_class, bindings = nil, &block)
+      if trace_by_default
+        return add_traced_route(name, path_spec, resource_type, model_class, bindings, &block)
+      else
+        return add_untraced_route(name, path_spec, resource_type, model_class, bindings, &block)
+      end
+    end
+    alias add add_route
+
+    def add_untraced_route(name, path_spec, resource_type, model_class, bindings = nil, &block)
       resource = bundle_typed_resource(resource_type, model_class, name)
       resource_route(resource, name, path_spec, bindings, &block)
     end
-    alias add add_route
+    alias add_untraced add_untraced_route
 
     def add_traced_route(name, path_spec, resource_type, model_class, bindings = nil, &block)
       resource = bundle_traced_resource(resource_type, model_class, name)

data/lib/roadforest/application/services-host.rb

@@ -5,6 +5,6 @@ class RoadForest::Application
     def initialize
     end
 
-    attr_accessor :router, :canonical_host, :type_handling
+    attr_accessor :router, :canonical_host, :type_handling, :logger
   end
 end

data/lib/roadforest/application.rb

@@ -9,17 +9,19 @@ require 'roadforest/application/path-provider'
 require 'roadforest/application/services-host'
 require 'roadforest/resource/rdf'
 require 'roadforest/content-handling/engine'
+require 'roadforest/rdf/normalization'
 
 module RoadForest
   class Application
+    include RDF::Normalization
     include Resource::Handlers
 
-    def initialize(canonical_host, services, configuration = nil, dispatcher = nil)
-      @canonical_host = ::RDF::URI.parse(canonical_host)
+    def initialize(canonical_host, services = nil, configuration = nil, dispatcher = nil)
+      @canonical_host = normalize_resource(canonical_host)
       configuration ||= Webmachine::Configuration.default
       dispatcher ||= Dispatcher.new(services)
       super(configuration, dispatcher)
-      self.services = services
+      self.services = services unless services.nil?
 
       setup
     end
@@ -27,16 +29,21 @@ module RoadForest
     def setup
     end
 
-    attr_reader :services, :canonical_host
+    attr_accessor :services, :canonical_host
 
     alias router dispatcher
 
     def services=(service_host)
       router.services = service_host
       @services = service_host
-      @services.canonical_host = @canonical_host
+      @services.canonical_host = canonical_host
       @services.router = PathProvider.new(@dispatcher)
       @services.type_handling ||= ContentHandling::Engine.default
+      @services.logger ||=
+        begin
+          require 'logger'
+          Logger.new("roadforest.log")
+        end
     end
   end
 end

data/lib/roadforest/blob-model.rb

@@ -44,12 +44,18 @@ module RoadForest
       File::open(path)
     end
 
+    def incomplete_path
+      [path,"incomplete"].join(".")
+    end
+
     def update(incoming)
-      File::open(path, "w") do |file|
+      File::open(incomplete_path, "w") do |file|
         incoming.each do |chunk|
           file.write(chunk)
         end
       end
+      Pathname.new(incomplete_path).rename(path)
+
       return nil
     end
   end

data/lib/roadforest/content-handling/engine.rb

@@ -2,6 +2,8 @@ require 'roadforest/content-handling/media-type'
 
 module RoadForest
   module ContentHandling
+    class UnrecognizedType < ::StandardError; end
+
     class Engine
       class TypeHandlerList
         def initialize(prefix)
@@ -39,7 +41,7 @@ module RoadForest
           type = MediaType.parse(type)
           @handlers.fetch(type)
         rescue KeyError
-          raise "No Content-Type handler for #{content_type}"
+          raise UnrecognizedType, "No Content-Type handler for #{type}"
         end
       end
 
@@ -105,6 +107,7 @@ module RoadForest
       # Given the 'Accept' header and provided types, chooses an
       # appropriate media type.
       def choose_media_type(provided, header)
+        return "*/*" if header.nil?
         requested = MediaTypeList.build(header.split(/\s*,\s*/))
         requested.best_match_from(provided)
       end

data/lib/roadforest/content-handling/type-handlers/jsonld.rb

@@ -1,6 +1,7 @@
 #@require 'rdf/rdfa' #XXX Otherwise json-ld grabs RDFa documents. Awaiting fix
 #upstream
 require 'json/ld'
+require 'roadforest/rdf/normalization'
 
 module RoadForest
   module MediaType
@@ -13,13 +14,13 @@ module RoadForest
           end
           attr_reader :type, :handler
 
-          def local_to_network(network)
-            @handler.local_to_network(network)
+          def local_to_network(base_uri, network)
+            @handler.local_to_network(base_uri, network)
           end
           alias from_graph local_to_network
 
-          def network_to_local(source)
-            @handler.network_to_local(source)
+          def network_to_local(base_uri, source)
+            @handler.network_to_local(base_uri, source)
           end
           alias to_graph network_to_local
         end
@@ -46,23 +47,23 @@ module RoadForest
       end
 
       class Handler
-        def network_to_local(network)
+        def network_to_local(base_uri, network)
           return network
         end
 
-        def local_to_network(local)
+        def local_to_network(base_uri, local)
           return local
         end
 
         def parse_for(resource)
           source = resource.request_body
-          input_data = network_to_local(source)
           model = resource.model
+          input_data = network_to_local(model.my_url, source)
 
           update_model(model, input_data)
 
           renderer = model.type_handling.choose_renderer(resource.request_accept_header)
-          body = renderer.local_to_network(model.response_data)
+          body = renderer.local_to_network(model.my_url, model.response_data)
 
           build_response(resource)
         end
@@ -70,13 +71,13 @@ module RoadForest
         def render_for(resource)
           model = resource.model
           output_data = get_output(model)
-          local_to_network(output_data)
+          local_to_network(model.my_url,  output_data)
         end
 
         def add_child_to(resource)
           model = resource.model
           source = resource.request_body
-          input_data = network_to_local(source)
+          input_data = network_to_local(model.my_url, source)
 
           child_for_model(resource.model, input_data)
 
@@ -87,7 +88,7 @@ module RoadForest
           model = resource.model
 
           renderer = model.type_handling.choose_renderer(resource.request_accept_header)
-          body = renderer.local_to_network(model.response_data)
+          body = renderer.local_to_network(model.my_url, model.response_data)
 
           resource.response_content_type = renderer.content_type_header
           resource.response_body = body
@@ -115,8 +116,6 @@ module RoadForest
           result
         end
       end
-
-require 'roadforest/rdf/normalization'
       class RDFHandler < Handler
         include RDF::Normalization
 
@@ -150,17 +149,26 @@ require 'roadforest/rdf/normalization'
 
       #application/ld+json
       class JSONLD < RDFHandler
-        def local_to_network(rdf)
-          JSON::LD::Writer.buffer do |writer|
+        include RDF::Normalization
+
+        def local_to_network(base_uri, rdf)
+          raise "Invalid base uri: #{base_uri}" if base_uri.nil?
+          prefixes = relevant_prefixes_for_graph(rdf)
+          prefixes.keys.each do |prefix|
+            prefixes[prefix.to_sym] = prefixes[prefix]
+          end
+          JSON::LD::Writer.buffer(:base_uri => base_uri.to_s,
+                                  :prefixes => prefixes) do |writer|
             rdf.each_statement do |statement|
               writer << statement
             end
           end
         end
 
-        def network_to_local(source)
+        def network_to_local(base_uri, source)
+          raise "Invalid base uri: #{base_uri.inspect}" if base_uri.nil?
           graph = ::RDF::Graph.new
-          reader = JSON::LD::Reader.new(source.to_s)
+          reader = JSON::LD::Reader.new(source.to_s, :base_uri => base_uri.to_s)
           reader.each_statement do |statement|
             graph.insert(statement)
           end

data/lib/roadforest/http/adapters/excon.rb

@@ -27,7 +27,7 @@ module RoadForest
         excon_response = connection.request(
           :method => request.method,
           :path => uri.path,
-          :headers => request.headers,
+          :headers => {"Host" => uri.host}.merge(request.headers),
           :body => request.body
         )
 

data/lib/roadforest/http/graph-response.rb

@@ -1,20 +1,34 @@
 module RoadForest
   module HTTP
-    class GraphResponse
-      attr_accessor :graph
+    class BaseResponse
       attr_reader :request, :response
 
-      def initialize(request, response, graph)
-        @request, @response, @graph = request, response, graph
+      def initialize(request, response)
+        @request, @response = request, response
       end
 
       def url
         request.url
       end
 
+      def etag
+        response.etag
+      end
+
       def status
         response.status
       end
+
+      def raw_body
+        response.body
+      end
+    end
+
+    class UnparseableResponse < BaseResponse
+    end
+
+    class GraphResponse < BaseResponse
+      attr_accessor :graph
     end
   end
 end

data/lib/roadforest/http/graph-transfer.rb

@@ -5,11 +5,18 @@ require 'roadforest/content-handling/engine'
 module RoadForest
   module HTTP
     class GraphTransfer
-      attr_accessor :http_client
+      class Retryable < StandardError; end
+
+      attr_accessor :http_client, :trace
       attr_writer :type_handling
+      attr_reader :graph_cache
 
       def initialize
+        @trace = nil
         @type_preferences = Hash.new{|h,k| k.nil? ? "*/*" : h[nil]}
+        @graph_cache = Hash.new do |cache, url|
+          cache[url] = {}
+        end
       end
 
       def type_handling
@@ -37,7 +44,20 @@ module RoadForest
 
         response = send_request(request, graph)
 
-        return build_response(request, response)
+        case response
+        when HTTP::Response
+          response = build_response(request, response)
+          cache_response(response)
+          return response
+        when GraphResponse
+          return response
+        end
+      end
+
+      def cache_response(response)
+        return if response.etag.nil?
+        return if response.etag.empty?
+        graph_cache[response.url][response.etag] = response
       end
 
       def validate(method, url, graph)
@@ -59,9 +79,18 @@ module RoadForest
       def setup_request(method, url)
         request = Request.new(method, url)
         request.headers["Accept"] = type_handling.parsers.types.accept_header
+        add_cache_headers(request)
         request
       end
 
+      def add_cache_headers(request)
+        return unless request.method == "GET"
+        return unless graph_cache.has_key?(request.url)
+        cached = graph_cache[request.url]
+        return if cached.empty?
+        request.headers["If-None-Match"] = cached.keys.join(", ")
+      end
+
       def select_renderer(url)
       end
 
@@ -77,17 +106,28 @@ module RoadForest
         content_type = best_type_for(request.url)
         renderer = type_handling.choose_renderer(content_type)
         request.headers["Content-Type"] = renderer.content_type_header
-        request.body_string = renderer.from_graph(graph)
+        request.body_string = renderer.from_graph(request.url, graph)
       end
 
-      class Retryable < StandardError; end
+      def trace_message(message)
+        return unless @trace
+        @trace = $stdout unless IO === @trace
+        @trace.puts message.inspect
+      end
 
       def send_request(request, graph)
         retry_limit ||= 5
+        #Check expires headers on received
         render_graph(graph, request)
 
+        trace_message(request)
         response = http_client.do_request(request)
+        trace_message(response)
         case response.status
+        when 304 #Not Modified
+          response = graph_cache.fetch(request.url).fetch(response.etag)
+          trace_message(response)
+          return response
         when 415 #Type not accepted
           record_accept_header(request.url, response.headers["Accept"])
           raise Retryable
@@ -98,14 +138,18 @@ module RoadForest
         retry
       end
 
-      def parse_response(response)
+      def parse_response(base_uri, response)
         parser = type_handling.choose_parser(response.headers["Content-Type"])
-        parser.to_graph(response.body_string)
+        parser.to_graph(base_uri, response.body_string)
       end
 
       def build_response(request, response)
-        graph = parse_response(response)
-        return GraphResponse.new(request, response, graph)
+        graph = parse_response(request.url, response)
+        response = GraphResponse.new(request, response)
+        response.graph = graph
+        return response
+      rescue ContentHandling::UnrecognizedType
+        return UnparseableResponse.new(request, response)
       end
     end
   end

data/lib/roadforest/http/message.rb

@@ -69,6 +69,11 @@ module RoadForest
       def initialize(method, url)
         super()
         @method, @url = method, url
+        headers["Host"] = Addressable::URI.parse(url).host
+      end
+
+      def inspect
+        "\n" + super
       end
 
       def needs_body?
@@ -76,13 +81,17 @@ module RoadForest
       end
 
       def inspection_payload
-        ["#{method} #{url}"] + super
+        [url, "#{method} #{url.path}"] + super
       end
     end
 
     class Response < Message
       attr_accessor :status
 
+      def etag
+        headers["ETag"]
+      end
+
       def inspection_payload
         [status] + super
       end

data/lib/roadforest/model.rb

@@ -12,6 +12,7 @@ module RoadForest
       @response_values = {}
     end
     attr_reader :route_name, :params, :services, :data
+    attr_reader :response_values
 
     def path_for(route_name = nil, params = nil)
       services.router.path_for(route_name, (params || self.params).to_hash)
@@ -103,7 +104,10 @@ module RoadForest
 
   end
 
+  require 'roadforest/rdf/etagging'
   class RDFModel < Model
+    include RDF::Etagging
+
     def update(graph)
       graph_update(start_focus(graph))
     end
@@ -137,13 +141,22 @@ module RoadForest
       return focus
     end
 
-    def start_graph(resource_url=nil, &block)
-      graph = ::RDF::Graph.new
-      start_focus(graph, resource_url, &block)
+    def etag
+      @etag ||= etag_from(etag_graph)
+    end
+
+    def etag_graph
+      current_graph
+    end
+
+    def current_graph
+      return response_data if response_values.has_key?(:data)
+      new_graph
     end
 
     def new_graph
-      focus = start_graph(my_url)
+      graph = ::RDF::Graph.new
+      focus = start_focus(graph, my_url)
       fill_graph(focus)
       self.response_data = focus.graph
     end

data/lib/roadforest/rdf/context-fascade.rb

@@ -1,25 +1,100 @@
 require 'rdf'
+require 'roadforest/rdf/resource-query'
+require 'roadforest/rdf/resource-pattern'
+require 'roadforest/rdf/normalization'
 
 module RoadForest::RDF
   class ContextFascade
     include ::RDF::Countable
     include ::RDF::Enumerable
     include ::RDF::Queryable
+    include Normalization
 
-    def initialize(store, resource, rigor)
-      @store, @resource, @rigor = store, resource, rigor
+    attr_accessor :resource, :rigor, :source_graph, :target_graph, :copied_contexts
+
+    def initialize
+      @copied_contexts = {}
+    end
+
+    def resource=(resource)
+      @resource = normalize_context(resource)
+    end
+
+    def dup
+      other = self.class.allocate
+      other.resource = self.resource
+      other.rigor = self.rigor
+
+      other.copied_contexts = self.copied_contexts
+      other.source_graph = self.source_graph
+      other.target_graph = self.target_graph
+      return other
+    end
+
+    def parceller
+      @parceller ||=
+        begin
+          parceller = Parcel.new
+          parceller.graph = source_graph
+          parceller
+        end
+    end
+
+    def copy_context
+      return if copied_contexts[resource]
+      return if target_graph.nil? or source_graph == target_graph
+      parceller.graph_for(resource).each_statement do |statement|
+        statement.context = resource
+        target_graph << statement
+      end
+      copied_contexts[resource] = true
+    end
+
+    #superfluous?
+    def build_query
+      ResourceQuery.new([], {}) do |query|
+        query.subject_context = resource
+        query.source_rigor = rigor
+        yield query
+      end
     end
 
     def query_execute(query, &block)
-      ResourceQuery.from(query, @resource, @rigor).execute(@store, &block)
+      query = ResourceQuery.from(query, resource, rigor)
+      execute_search(query, &block)
     end
 
     def query_pattern(pattern, &block)
-      ResourcePattern.from(pattern, {:context_roles => {:subject => @resource}, :source_rigor => @rigor}).execute(@store, &block)
+      pattern = ResourcePattern.from(pattern, {:context_roles => {:subject => resource}, :source_rigor => rigor})
+      execute_search(pattern, &block)
+    end
+
+    def execute_search(search, &block)
+      if target_graph != source_graph and not target_graph.nil?
+        enum = search.execute(target_graph)
+        if enum.any?{ true }
+          enum.each(&block)
+          return enum
+        end
+      end
+      search.execute(source_graph, &block)
     end
 
     def each(&block)
-      @store.each(&block)
+      source_graph.each(&block)
+    end
+
+    def insert(statement)
+      copy_context
+      statement[3] = resource
+      target_graph.insert(statement)
+    end
+
+    def delete(statement)
+      statement = RDF::Query::Pattern.from(statement)
+      statement.context = resource
+      copy_context
+      target_graph.delete(statement)
     end
   end
 end

data/lib/roadforest/rdf/etagging.rb

@@ -0,0 +1,53 @@
+require 'roadforest/rdf'
+
+module RoadForest::RDF
+  module Etagging
+    def etag_from(graph)
+      require 'openssl'
+      quads = sorted_quads(graph)
+      mapped = blank_mapped(quads)
+      strings = mapped.map(&:inspect)
+
+      ripe = OpenSSL::Digest::RIPEMD160.new
+      mapped.each do |quad|
+        ripe << quad.inspect
+      end
+      "W/\"#{ripe.base64digest}\""
+    end
+
+    def blank_mapped(quads)
+      sequence = 0
+      mapping = Hash.new do |h,k|
+        h[k] = RDF::Node.new(sequence+=1)
+      end
+
+      quads.map do |quad|
+        quad.map do |term|
+          case term
+          when RDF::Node
+            mapping[term].to_s
+          when nil
+            nil
+          else
+            term.to_s
+          end
+        end
+      end
+    end
+
+    def sorted_quads(graph)
+      graph.statements.map do |statement|
+        [statement.subject, statement.predicate, statement.object, statement.context]
+      end.sort_by do |quad|
+        quad.map do |term|
+          case term
+          when RDF::Node
+            nil
+          else
+            term
+          end
+        end.join("/")
+      end
+    end
+  end
+end