roadforest 0.0.1

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

@@ -0,0 +1,172 @@
+#@require 'rdf/rdfa' #XXX Otherwise json-ld grabs RDFa documents. Awaiting fix
+#upstream
+require 'json/ld'
+
+module RoadForest
+  module MediaType
+    module Handlers
+      module Wrap
+        class Wrapper
+          def initialize(type, handler)
+            @type = type
+            @handler = handler
+          end
+          attr_reader :type, :handler
+
+          def local_to_network(network)
+            @handler.local_to_network(network)
+          end
+          alias from_graph local_to_network
+
+          def network_to_local(source)
+            @handler.network_to_local(source)
+          end
+          alias to_graph network_to_local
+        end
+
+        class Render < Wrapper
+          def call(resource)
+            @handler.render_for(resource)
+          end
+
+          def content_type_header
+            @type.content_type_header
+          end
+        end
+
+        class Parse < Wrapper
+          def call(resource)
+            @handler.parse_for(resource)
+          end
+
+          def add_child(resource)
+            @handler.add_child_to(resource)
+          end
+        end
+      end
+
+      class Handler
+        def network_to_local(network)
+          return network
+        end
+
+        def local_to_network(local)
+          return local
+        end
+
+        def parse_for(resource)
+          source = resource.request_body
+          input_data = network_to_local(source)
+          model = resource.model
+
+          update_model(model, input_data)
+
+          renderer = model.type_handling.choose_renderer(resource.request_accept_header)
+          body = renderer.local_to_network(model.response_data)
+
+          build_response(resource)
+        end
+
+        def render_for(resource)
+          model = resource.model
+          output_data = get_output(model)
+          local_to_network(output_data)
+        end
+
+        def add_child_to(resource)
+          model = resource.model
+          source = resource.request_body
+          input_data = network_to_local(source)
+
+          child_for_model(resource.model, input_data)
+
+          build_response(resource)
+        end
+
+        def build_response(resource)
+          model = resource.model
+
+          renderer = model.type_handling.choose_renderer(resource.request_accept_header)
+          body = renderer.local_to_network(model.response_data)
+
+          resource.response_content_type = renderer.content_type_header
+          resource.response_body = body
+          if model.response_location
+            resource.redirect_to(model.response_location)
+          end
+        end
+
+        def child_for_model(model, data)
+          model.add_child(data)
+          model.processed
+        end
+
+        def update_model(model, input_data)
+          result = model.update(input_data)
+          model.response_data = result
+          model.processed
+          result
+        end
+
+        def get_output(model)
+          result = model.retrieve
+          model.response_data = result
+          model.processed
+          result
+        end
+      end
+
+require 'roadforest/rdf/normalization'
+      class RDFHandler < Handler
+        include RDF::Normalization
+
+        def get_output(model)
+          graph = super
+          root_uri = model.canonical_uri
+
+          graph.each_statement do |statement|
+            original = statement.dup
+            if ::RDF::URI === statement.subject and statement.subject.relative?
+              statement.subject = normalize_resource(root_uri.join(statement.subject))
+            end
+
+            if ::RDF::URI === statement.object and statement.object.relative?
+              statement.object = normalize_resource(root_uri.join(statement.object))
+            end
+
+            if statement != original
+              graph.delete(original)
+              graph.insert(statement)
+            end
+          end
+          graph
+        end
+
+        def child_for_model(model, data)
+          model.add_graph_child(data)
+          model.processed
+        end
+      end
+
+      #application/ld+json
+      class JSONLD < RDFHandler
+        def local_to_network(rdf)
+          JSON::LD::Writer.buffer do |writer|
+            rdf.each_statement do |statement|
+              writer << statement
+            end
+          end
+        end
+
+        def network_to_local(source)
+          graph = ::RDF::Graph.new
+          reader = JSON::LD::Reader.new(source.to_s)
+          reader.each_statement do |statement|
+            graph.insert(statement)
+          end
+          graph
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'addressable/uri'
+require 'excon'
+require 'roadforest/http/message'
+module RoadForest
+  module HTTP
+    class ExconAdapter
+      def initialize(url)
+        @root_url = Addressable::URI.parse(url)
+        @connections = Hash.new{|h,k| h[k] = build_site_connection(k)}
+        @connection_defaults = {}
+      end
+      attr_reader :connection_defaults
+
+      def build_site_connection(site)
+        Excon.new(site.to_s, @connection_defaults)
+      end
+
+      def site_connection(uri)
+        uri = Addressable::URI.parse(uri)
+        @connections[uri.normalized_site]
+      end
+
+      def do_request(request)
+        uri = @root_url.join(request.url)
+
+        connection = site_connection(uri)
+        excon_response = connection.request(
+          :method => request.method,
+          :path => uri.path,
+          :headers => request.headers,
+          :body => request.body
+        )
+
+        response = HTTP::Response.new
+        if excon_response.body.is_a? String
+          response.body_string = excon_response.body
+        else
+          response.body = excon_response.body
+        end
+        response.headers = excon_response.headers
+        response.status = excon_response.status
+
+        return response
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module RoadForest
+  module HTTP
+    class GraphResponse
+      attr_accessor :graph
+      attr_reader :request, :response
+
+      def initialize(request, response, graph)
+        @request, @response, @graph = request, response, graph
+      end
+
+      def url
+        request.url
+      end
+
+      def status
+        response.status
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+require 'roadforest/http/message'
+require 'roadforest/http/graph-response'
+require 'roadforest/content-handling/engine'
+
+module RoadForest
+  module HTTP
+    class GraphTransfer
+      attr_accessor :http_client
+      attr_writer :type_handling
+
+      def initialize
+        @type_preferences = Hash.new{|h,k| k.nil? ? "*/*" : h[nil]}
+      end
+
+      def type_handling
+        @type_handling ||= ContentHandling::Engine.default
+      end
+
+      def put(url, graph)
+        make_request("PUT", url, graph)
+      end
+
+      def get(url)
+        make_request("GET", url)
+      end
+
+      def post(url, graph)
+        make_request("POST", url, graph)
+      end
+
+      def make_request(method, url, graph=nil)
+        method = method.to_s.upcase
+
+        validate(method, url, graph)
+
+        request = setup_request(method, url)
+
+        response = send_request(request, graph)
+
+        return build_response(request, response)
+      end
+
+      def validate(method, url, graph)
+        case method
+        when "GET", "HEAD", "DELETE"
+          raise "Method #{method} requires an empty body" unless graph.nil?
+        when "POST", "PATCH", "PUT"
+          raise "Method #{method} requires a body" if graph.nil?
+        #when "OPTION", "TRACE" #Need to put verbs where they go
+        else
+          raise "Unrecognized method: #{method}"
+        end
+      end
+
+      def best_type_for(url)
+        return @type_preferences[url]
+      end
+
+      def setup_request(method, url)
+        request = Request.new(method, url)
+        request.headers["Accept"] = type_handling.parsers.types.accept_header
+        request
+      end
+
+      def select_renderer(url)
+      end
+
+      def record_accept_header(url, types)
+        return if types.nil? or types.empty?
+        @type_preferences[nil] = types
+        @type_preferences[url] = types
+      end
+
+      def render_graph(graph, request)
+        return unless request.needs_body?
+
+        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)
+      end
+
+      class Retryable < StandardError; end
+
+      def send_request(request, graph)
+        retry_limit ||= 5
+        render_graph(graph, request)
+
+        response = http_client.do_request(request)
+        case response.status
+        when 415 #Type not accepted
+          record_accept_header(request.url, response.headers["Accept"])
+          raise Retryable
+        end
+        return response
+      rescue Retryable
+        raise unless (retry_limit -= 1) > 0
+        retry
+      end
+
+      def parse_response(response)
+        parser = type_handling.choose_parser(response.headers["Content-Type"])
+        parser.to_graph(response.body_string)
+      end
+
+      def build_response(request, response)
+        graph = parse_response(response)
+        return GraphResponse.new(request, response, graph)
+      end
+    end
+  end
+end

data/lib/roadforest/http/message.rb

@@ -0,0 +1,91 @@
+
+require 'stringio'
+
+module RoadForest
+  module HTTP
+    class Message
+      attr_accessor :headers
+
+      def initialize
+        @body_string = ""
+        @headers = {}
+      end
+
+      def body_string=(value)
+        @body_string = value
+        @body = nil
+      end
+
+      def body=(value)
+        @body = value
+        @body_string = nil
+      end
+
+      def body
+        return @body ||= StringIO.new(body_string||"")
+      end
+
+      def body_string
+        @body_string ||=
+          begin
+            case @body
+            when nil
+              nil
+            when StringIO
+              @body.string
+            when IO
+              @body.rewind
+              @body.read
+            else
+              raise "Unknown class for body: #{@body.class.name}"
+            end
+          end
+      end
+
+      def inspect
+        "#<#{self.class.name}:#{'0x%0xd'%object_id}\n  #{inspection_payload.join("\n  ")}\n>"
+      end
+
+      def inspection_payload
+        old_pos = body.pos
+        body.rewind
+        [headers.inspect, body.read]
+      ensure
+        body.pos = old_pos
+      end
+
+      def empty?
+        if @body.nil?
+          @body_string.nil? || @body_string.empty?
+        else
+          @body.respond_to?(:size) && @body.size <= 0
+        end
+      end
+    end
+
+    class Request < Message
+      attr_accessor :method, :url
+
+      def initialize(method, url)
+        super()
+        @method, @url = method, url
+      end
+
+      def needs_body?
+        %w{POST PATCH PUT}.include?(@method)
+      end
+
+      def inspection_payload
+        ["#{method} #{url}"] + super
+      end
+    end
+
+    class Response < Message
+      attr_accessor :status
+
+      def inspection_payload
+        [status] + super
+      end
+    end
+  end
+end

data/lib/roadforest/model.rb

@@ -0,0 +1,151 @@
+require 'roadforest/rdf/graph-store'
+module RoadForest
+  class ProcessingSequenceError < StandardError
+  end
+
+  class Model
+    def initialize(route_name, params, services)
+      @route_name = route_name
+      @params = params
+      @services = services
+      @data = nil
+      @response_values = {}
+    end
+    attr_reader :route_name, :params, :services, :data
+
+    def path_for(route_name = nil, params = nil)
+      services.router.path_for(route_name, (params || self.params).to_hash)
+    end
+
+    def canonical_host
+      services.canonical_host
+    end
+
+    def canonical_uri
+      Addressable::URI.parse(canonical_host.to_s).join(my_path)
+    end
+
+    def type_handling
+      services.type_handling
+    end
+
+    def my_path
+      path_for(route_name, params)
+    end
+
+    def my_url
+      canonical_uri.to_s
+    end
+
+    def reset
+    end
+
+    def exists?
+      !data.nil?
+    end
+
+    def etag
+      nil
+    end
+
+    def last_modified
+      nil
+    end
+
+    def response_location
+      @response_values.fetch(:location) do
+        raise ProcessingSequenceError, "Location not available until request processed"
+      end
+    end
+
+    def response_location=(location)
+      @response_values[:location] = location
+    end
+
+    def response_data
+      @response_values.fetch(:data) do
+        raise ProcessingSequenceError, "Location not available until request processed"
+      end
+    end
+
+    def response_data=(data)
+      @response_values[:data] = data
+    end
+
+    def processed
+      [:location, :data].each do |key|
+        unless @response_values.has_key?(key)
+          @response_values[key] = nil
+        end
+      end
+    end
+
+    def expires
+      nil
+    end
+
+    def update(data)
+      raise NotImplementedError
+    end
+
+    def add_child(results)
+      raise NotImplementedError
+    end
+
+    def retrieve
+      raise NotImplementedError
+    end
+    alias retreive retrieve
+
+    def delete
+      false
+    end
+
+  end
+
+  class RDFModel < Model
+    def update(graph)
+      graph_update(start_focus(graph))
+    end
+
+    def graph_update(focus)
+      fill_graph(focus)
+    end
+
+    def add_graph_child(graph)
+      add_child(start_focus(graph))
+      new_graph
+    end
+
+    def add_child(focus)
+      new_graph
+    end
+
+    def retrieve
+      new_graph
+    end
+
+    def fill_graph(graph)
+    end
+
+    def start_focus(graph, resource_url=nil)
+      focus = RDF::GraphFocus.new
+      focus.graph = graph
+      focus.subject = resource_url || my_url
+
+      yield focus if block_given?
+      return focus
+    end
+
+    def start_graph(resource_url=nil, &block)
+      graph = ::RDF::Graph.new
+      start_focus(graph, resource_url, &block)
+    end
+
+    def new_graph
+      focus = start_graph(my_url)
+      fill_graph(focus)
+      self.response_data = focus.graph
+    end
+  end
+end

data/lib/roadforest/models.rb

@@ -0,0 +1,2 @@
+require 'roadforest/model'
+require 'roadforest/blob-model'

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

@@ -0,0 +1,25 @@
+require 'rdf'
+
+module RoadForest::RDF
+  class ContextFascade
+    include ::RDF::Countable
+    include ::RDF::Enumerable
+    include ::RDF::Queryable
+
+    def initialize(store, resource, rigor)
+      @store, @resource, @rigor = store, resource, rigor
+    end
+
+    def query_execute(query, &block)
+      ResourceQuery.from(query, @resource, @rigor).execute(@store, &block)
+    end
+
+    def query_pattern(pattern, &block)
+      ResourcePattern.from(pattern, {:context_roles => {:subject => @resource}, :source_rigor => @rigor}).execute(@store, &block)
+    end
+
+    def each(&block)
+      @store.each(&block)
+    end
+  end
+end

data/lib/roadforest/rdf/document.rb

@@ -0,0 +1,23 @@
+require 'stringio'
+require 'roadforest'
+
+module RoadForest::RDF
+  #Wrapper for text to be parsed into RDF
+  class Document
+    attr_accessor :content_type, :code, :source, :root_url, :body, :body_string
+    def initialize
+      @content_type = "text/html"
+      @code = 200
+      @body_string = ""
+    end
+
+    def body_string=(value)
+      @body_string = value
+      @body = nil
+    end
+
+    def body
+      return @body ||= StringIO.new(body_string)
+    end
+  end
+end

data/lib/roadforest/rdf/focus-list.rb

@@ -0,0 +1,19 @@
+require 'roadforest/rdf/focus-wrapping'
+require 'roadforest/rdf/normalization'
+module RoadForest::RDF
+  class FocusList < ::RDF::List
+    include Normalization
+
+    attr_accessor :root_url, :base_node, :source_rigor
+
+    def first
+      base_node.unwrap_value(super)
+    end
+
+    def each
+      super do |value|
+        yield base_node.unwrap_value(value)
+      end
+    end
+  end
+end

data/lib/roadforest/rdf/focus-wrapping.rb

@@ -0,0 +1,30 @@
+require 'rdf/model/node'
+
+module RoadForest::RDF
+  module FocusWrapping
+    def new_focus
+      dup
+    end
+
+    def wrap_node(value)
+      next_step = new_focus
+      if ::RDF::Node === value
+        next_step.root_url = self.root_url
+      else
+        next_step.root_url = normalize_context(value)
+      end
+      next_step.subject = value
+      next_step.graph = graph
+      next_step.source_rigor = source_rigor
+      next_step
+    end
+
+    def unwrap_value(value)
+      if value.respond_to? :object
+        value.object
+      else
+        wrap_node(value)
+      end
+    end
+  end
+end

data/lib/roadforest/rdf/graph-copier.rb

@@ -0,0 +1,16 @@
+require 'rdf'
+require 'roadforest/rdf/graph-focus'
+
+module RoadForest
+  module RDF
+    class GraphCopier < GraphFocus
+      attr_accessor :source_graph, :subject
+
+      alias target_graph graph
+
+      def initialize
+        @graph = ::RDF::Graph.new
+      end
+    end
+  end
+end