roadforest 0.0.3 → 0.1

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

@@ -0,0 +1,297 @@
+require 'roadforest/content-handling/type-handlers/rdf-handler'
+
+module RoadForest
+  module MediaType
+    module Handlers
+      #application/x-www-form-urlencoded
+      class RDFPost < RDFHandler
+
+        #c.f. http://www.lsrn.org/semweb/rdfpost.html
+        class Reader < ::RDF::Reader
+          module St
+            class State
+              def initialize(reader)
+                @reader = reader
+                @accept_hash = cleanup(accept_list)
+              end
+
+              def cleanup(accept_list)
+                hash = Hash.new{ accept_list[nil] }
+                accept_list.each_key do |key|
+                  next if key.nil?
+                  hash[key.to_s] = accept_list[key]
+                end
+                hash
+              end
+
+              def blank_node(name)
+                ::RDF::Node.new(name)
+              end
+
+              def base_uri
+                ::RDF::URI.intern(@reader.options[:base_uri])
+              end
+
+              def uri(string)
+                base_uri.join(string)
+              end
+
+              def prefix_uri(name)
+                ::RDF::URI.intern(@reader.options[:prefixes][name])
+              end
+
+              def clear_subject
+                @reader.subject = nil
+                @reader.subject_prefix = nil
+              end
+
+              def clear_predicate
+                @reader.predicate = nil
+                @reader.predicate_prefix = nil
+              end
+
+              def clear_object
+                @reader.object = nil
+                @reader.object_prefix = nil
+              end
+
+              def consume_next(name)
+                consume
+                next_state(name)
+              end
+
+              def consume
+                @reader.consume_pair
+              end
+
+              def triple_complete
+                @reader.new_triple = true
+              end
+
+              def next_state(name)
+                @reader.current_state = @reader.states.fetch(name)
+              end
+
+              def accept(key, value)
+                #puts "#{[self.class.to_s.sub(/.*:/,''), key,
+                #value.sub(/\s*\Z/,'')].inspect}"
+                @accept_hash[key][value.sub(/\s*\Z/,'')]
+              end
+            end
+
+            class RDF < State
+              def accept_list
+                { rdf: proc{|v| consume_next(:def_ns_decl) },
+                  nil => proc{ consume } }
+              end
+            end
+
+            class DefNsDecl < State
+              def accept_list
+                { v: proc {|v| consume_next(:ns_decl); @reader.options[:prefixes][nil] = v},
+                  nil => proc{|v| next_state(:ns_decl)}}
+              end
+            end
+
+            class NsDecl < State
+              def accept_list
+                { n: proc{|v| consume_next(:ns_decl_suffix); @reader.namespace_prefix = v},
+                  nil => proc{|v| next_state(:subject)}}
+              end
+            end
+
+            class NsDeclSuffix < State
+              def accept_list
+                { v: proc{|v| consume_next(:ns_decl); @reader.options[:prefixes][@reader.namespace_prefix] = v},
+                  nil => proc{ next_state(:ns_decl)}}
+              end
+            end
+
+            class SkipToSubject < State
+              def accept_list
+                next_is_subject = proc{ next_state(:subject); clear_subject; clear_predicate; clear_object }
+                {
+                  sb: next_is_subject,
+                  su: next_is_subject,
+                  sv: next_is_subject,
+                  sn: next_is_subject,
+                  nil => proc{ consume }
+                }
+              end
+            end
+
+            class SkipToSubjectOrPred < SkipToSubject
+              def accept_list
+                next_is_pred = proc{ next_state(:predicate); clear_predicate; clear_object }
+                super.merge( pu: next_is_pred, pv: next_is_pred, pn: next_is_pred )
+              end
+            end
+
+            class Subject < State
+              def accept_list
+                {
+                  sb: proc{|v| consume_next(:predicate); @reader.subject = blank_node(v)},
+                  su: proc{|v| consume_next(:predicate); @reader.subject = uri(v)},
+                  sv: proc{|v| consume_next(:predicate); @reader.subject = prefix_url(nil) / v},
+                  sn: proc{|v| consume_next(:subject_suffix); @reader.subject_prefix = prefix_uri(v)},
+                  nil => proc{ consume }
+                }
+              end
+            end
+
+            class SubjectSuffix < State
+              def accept_list
+                {
+                  sv: proc{|v| consume_next(:predicate); @reader.subject = @reader.subject_prefix/v},
+                  nil => proc{ next_state(:skip_to_subject)}
+                }
+              end
+            end
+
+            class Predicate < State
+              def accept_list
+                {
+                  pu: proc {|v| @reader.predicate = uri(v); consume_next(:object)},
+                  pv: proc {|v| @reader.predicate = prefix_uri(nil) / v; consume_next(:object)},
+                  pn: proc {|v| @reader.predicate_prefix = prefix_uri(v); consume_next(:predicate_suffix)},
+                  nil => proc { next_state(:skip_to_subject)}
+                }
+              end
+            end
+
+            class PredicateSuffix < State
+              def accept_list
+                {
+                  pv: proc{|v| consume_next(:object); @reader.predicate = @reader.predicate_prefix/v},
+                  nil => proc{ next_state(:skip_to_subject)}
+                }
+              end
+            end
+
+            class Object < State
+              def accept_list
+                {
+                  ob: proc{|v| consume; triple_complete; @reader.object = blank_node(v)},
+                  ou: proc{|v| consume; triple_complete; @reader.object = uri(v)},
+                  ov: proc{|v| consume; triple_complete; @reader.object = prefix_uri(nil) / v},
+                  on: proc{|v| consume_next(:object_suffix); @reader.object_prefix = prefix_uri(v)},
+                  ol: proc{|v| consume_next(:type_or_lang); @reader.object = v},
+                  ll: proc{|v| consume_next(:object_literal); @reader.object_lang = v},
+                  lt: proc{|v| consume_next(:object_literal); @reader.object_type = v},
+                  nil => proc{ next_state(:skip_to_subj_or_pred) }
+                }
+              end
+            end
+
+            class ObjectSuffix < State
+              def accept_list
+                {
+                  ov: proc{|v| consume_next(:object); triple_complete; @reader.object = @reader.object_prefix/v},
+                  nil => proc{ next_state(:skip_to_subj_or_pred)}
+                }
+              end
+            end
+
+            class ObjectLiteral < State
+              def accept_list
+                {
+                  ol: proc{|v| consume_next(:type_or_lang); @reader.object = v},
+                  ll: proc{|v| consume; @reader.object_lang = v},
+                  lt: proc{|v| consume; @reader.object_type = v},
+                  nil => proc{ next_state(:skip_to_subj_or_pred)}
+                }
+              end
+            end
+
+            class TypeOrLang < State
+              def accept_list
+                {
+                  ll: proc{|v| consume; @reader.object_lang = v},
+                  lt: proc{|v| consume; @reader.object_type = v},
+                  nil => proc{ next_state(:object); triple_complete }
+                }
+              end
+            end
+          end
+
+          def initialize(input, options=nil, &block)
+            super(input, options||{}, &block)
+
+            @lineno = 0
+            @new_triple = false
+
+            @states = {
+              :rdf => St::RDF.new(self),
+              :def_ns_decl => St::DefNsDecl.new(self),
+              :ns_decl => St::NsDecl.new(self),
+              :ns_decl_suffix => St::NsDeclSuffix.new(self),
+              :skip_to_subject => St::SkipToSubject.new(self),
+              :skip_to_subj_or_pred => St::SkipToSubjectOrPred.new(self),
+              :subject => St::Subject.new(self),
+              :subject_suffix => St::SubjectSuffix.new(self),
+              :predicate => St::Predicate.new(self),
+              :predicate_suffix => St::PredicateSuffix.new(self),
+              :object => St::Object.new(self),
+              :object_suffix => St::ObjectSuffix.new(self),
+              :object_literal => St::ObjectLiteral.new(self),
+              :type_or_lang => St::TypeOrLang.new(self)
+            }
+
+            @current_state = @states.fetch(:rdf)
+          end
+          attr_reader :lineno, :states
+          attr_accessor :current_state
+          attr_accessor :new_triple, :subject, :predicate, :object
+          attr_accessor :object_type, :object_lang
+          attr_accessor :namespace_prefix, :subject_prefix, :predicate_prefix, :object_prefix
+
+          def read_triple
+            if @lineno >= @input.length
+              raise EOFError
+            end
+            while @lineno < @input.length
+              @current_state.accept(*@input[@lineno])
+              if @new_triple
+                @new_triple = false
+                return build_triple
+              end
+            end
+            return build_triple
+          end
+
+          def build_triple
+            object = @object
+            if object.is_a? String
+              object = ::RDF::Literal.new(object, :datatype => object_type, :language => object_lang)
+            end
+            @object_type = nil
+            @object_lang = nil
+
+            [@subject, @predicate, object]
+          end
+
+          def rewind
+            @lineno = 0
+          end
+
+          def consume_pair
+            @lineno += 1
+          end
+        end
+
+        def local_to_network(base_uri, graph)
+        end
+
+        def network_to_local(base_uri, list)
+          raise "Invalid base uri: #{base_uri.inspect}" if base_uri.nil?
+          graph = ::RDF::Graph.new
+          reader = Reader.new(list, :base_uri => base_uri.to_s)
+          reader.each_statement do |statement|
+            graph.insert(statement)
+          end
+          graph
+        end
+      end
+    end
+  end
+end

data/lib/roadforest/debug.rb

@@ -0,0 +1,10 @@
+module RoadForest
+  class << self
+    attr_accessor :debug_io
+
+    def debug(message)
+      return if @debug_io.nil?
+      @debug_io.puts(message)
+    end
+  end
+end

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

@@ -1,14 +1,10 @@
 module RoadForest
   module HTTP
     class BaseResponse
-      attr_reader :request, :response
+      attr_reader :url, :response
 
-      def initialize(request, response)
-        @request, @response = request, response
-      end
-
-      def url
-        request.url
+      def initialize(url, response)
+        @url, @response = url, response
       end
 
       def etag

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

@@ -1,26 +1,15 @@
-require 'roadforest/http/message'
-require 'roadforest/http/graph-response'
+require 'roadforest/http'
 require 'roadforest/content-handling/engine'
 
 module RoadForest
   module HTTP
     class GraphTransfer
-      class Retryable < StandardError; end
-
-      attr_accessor :http_client, :trace
       attr_writer :type_handling
-      attr_reader :graph_cache
+      attr_accessor :user_agent
 
-      def initialize
-        @trace = nil
+      def initialize(user_agent)
+        @user_agent = user_agent
         @type_preferences = Hash.new{|h,k| k.nil? ? "*/*" : h[nil]}
-        @graph_cache = Hash.new do |cache, url|
-          cache[url] = {}
-        end
-      end
-
-      def type_handling
-        @type_handling ||= ContentHandling::Engine.default
       end
 
       def put(url, graph)
@@ -35,121 +24,54 @@ module RoadForest
         make_request("POST", url, graph)
       end
 
-      def make_request(method, url, graph=nil)
-        method = method.to_s.upcase
+      def make_request(method, url, graph, retry_limit=5)
+        headers = {"Accept" => type_handling.parsers.types.accept_header}
+        body = nil
 
-        validate(method, url, graph)
-
-        request = setup_request(method, url)
+        if(%w{POST PUT PATCH}.include? method.upcase)
+          content_type = best_type_for(url)
+          renderer = type_handling.choose_renderer(content_type)
+          headers["Content-Type"] = renderer.content_type_header
+          body = renderer.from_graph(url, graph)
+        end
 
-        response = send_request(request, graph)
+        response = user_agent.make_request(method, url, headers, body, retry_limit)
 
-        case response
-        when HTTP::Response
-          response = build_response(request, response)
-          cache_response(response)
-          return response
-        when GraphResponse
-          return response
+        case response.status
+        when 415 #Type not accepted
+          record_accept_header(url, response.headers["Accept"])
+          raise Retryable
         end
-      end
 
-      def cache_response(response)
-        return if response.etag.nil?
-        return if response.etag.empty?
-        graph_cache[response.url][response.etag] = response
+        build_response(url, response)
+      rescue Retryable
+        raise unless (retry_limit -= 1) > 0
+        retry
       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
+      def type_handling
+        @type_handling ||= ContentHandling::Engine.default
       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
-        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
-
       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(request.url, graph)
-      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
-        end
-        return response
-      rescue Retryable
-        raise unless (retry_limit -= 1) > 0
-        retry
-      end
-
-      def parse_response(base_uri, response)
+      def build_response(url, response)
         parser = type_handling.choose_parser(response.headers["Content-Type"])
-        parser.to_graph(base_uri, response.body_string)
-      end
+        graph = parser.to_graph(url, response.body_string)
 
-      def build_response(request, response)
-        graph = parse_response(request.url, response)
-        response = GraphResponse.new(request, response)
+        response = GraphResponse.new(url, response)
         response.graph = graph
         return response
       rescue ContentHandling::UnrecognizedType
-        return UnparseableResponse.new(request, response)
+        return UnparseableResponse.new(url, response)
       end
     end
   end

data/lib/roadforest/http/keychain.rb

@@ -0,0 +1,79 @@
+require 'base64'
+require 'addressable/uri'
+
+module RoadForest
+  module HTTP
+    #Manages user credentials for HTTP Basic auth
+    class Keychain
+      class Credentials < Struct.new(:user, :secret)
+        def header_value
+          "Basic #{Base64.strict_encode64("#{user}:#{secret}")}"
+        end
+      end
+
+      def initialize
+        @realm_for_url = {}
+        @with_realm = {}
+      end
+
+      def add(url, user, secret, realm=nil)
+        creds = Credentials.new(user, secret)
+        add_credentials(url, creds, realm || :default)
+      end
+
+      def add_credentials(url, creds, realm)
+        if url.to_s[-1] != "/"
+          url << "/"
+        end
+        @realm_for_url[url.to_s] = realm
+
+        url = Addressable::URI.parse(url)
+        url.path = "/"
+        @with_realm[[url.to_s,realm]] = creds
+      end
+
+      BASIC_SCHEME = /basic\s+realm=(?<q>['"])(?<realm>(?:(?!['"]).)*)\k<q>/i
+
+      def challenge_response(url, challenge)
+        if (match = BASIC_SCHEME.match(challenge)).nil?
+          return nil
+        end
+        realm = match[:realm]
+
+        response(url, realm)
+      end
+
+      def response(url, realm)
+        lookup_url = Addressable::URI.parse(url)
+        lookup_url.path = "/"
+        creds = @with_realm[[lookup_url.to_s,realm]]
+        if creds.nil? and not realm.nil?
+          creds = missing_credentials(url, realm)
+          unless creds.nil?
+            add_credentials(url, creds, realm)
+          end
+        end
+
+        return nil if creds.nil?
+
+        return creds.header_value
+      end
+
+      def missing_credentials(url, realm)
+        nil
+      end
+
+      def preemptive_response(url)
+        url = Addressable::URI.parse(url)
+
+        while (realm = @realm_for_url[url.to_s]).nil?
+          new_url = url.join("..")
+          break if new_url == url
+          url = new_url
+        end
+
+        return response(url, realm)
+      end
+    end
+  end
+end

data/lib/roadforest/http/message.rb

@@ -47,9 +47,17 @@ module RoadForest
       end
 
       def inspection_payload
+        if body.respond_to? :pos
+          [headers.inspect, inspection_stream]
+        else
+          [headers.inspect, body]
+        end
+      end
+
+      def inspection_stream
         old_pos = body.pos
         body.rewind
-        [headers.inspect, body.read]
+        body.read
       ensure
         body.pos = old_pos
       end