roadforest 0.5 → 0.7

data/lib/roadforest/graph/nav-affordance-builder.rb

@@ -0,0 +1,62 @@
+require 'roadforest/graph'
+
+module RoadForest
+  module Graph
+    class NavAffordanceBuilder
+      def initialize(focus, path_provider)
+        @focus, @path_provider = focus, path_provider
+      end
+      attr_reader :path_provider, :focus
+
+      def to(name, params=nil)
+        route = path_provider.route_for_name(name)
+
+        pattern = iri_template(route, params)
+
+        node = ::RDF::Node.new
+        tmpl = ::RDF::Node.new
+        focus << [ node, ::RDF.type, Af.Navigate ]
+        focus << [ node, Af.target, tmpl ]
+        focus << [ tmpl, Af.pattern, pattern ]
+      end
+
+      def iri_template(route, params)
+        klass = route.interface_class
+        return if klass.nil?
+
+        variables = klass.path_params
+
+        params ||= {}
+        params = params.dup
+
+        variables -= params.keys
+
+        path_spec = route.resolve_path_spec(params)
+
+        path = path_provider.services.canonical_host.to_s.sub(%r{/$}, '') +
+          path_spec.map do |segment|
+          case segment
+          when Symbol
+            variables.delete(segment)
+            "{/#{segment}}"
+          when '*'
+            "{/extra*}"
+          else
+            "/" + segment.to_s
+          end
+          end.join("")
+
+          unless params.empty?
+            path += "?" + params.map do |key, value|
+              [key, value].join("=")
+            end.join("&")
+          end
+
+          unless variables.empty?
+            path += "{?#{variables.join(",")}}"
+          end
+      end
+    end
+  end
+
+end

data/lib/roadforest/graph/normalization.rb

@@ -6,7 +6,7 @@ module RoadForest::Graph
     Vocabs = {}
     Vocabs["rdf"] = RDF
 
-    def normalize_statement(subject, predicate, object, context)
+    def normalize_statement(subject, predicate, object, context=nil)
       subject = normalize_resource(subject) || RDF::Node.new
       predicate = normalize_uri(predicate)
       object = normalize_term(object) || RDF::Node.new
@@ -43,7 +43,7 @@ module RoadForest::Graph
     def normalize_context(from)
       case from
       when Array
-        from = expand_curie(from)
+        from = uri(expand_curie(from))
       when RDF::URI, Addressable::URI, String
         from = uri(from)
       else
@@ -107,7 +107,7 @@ module RoadForest::Graph
 
     def expand_curie_pair(prefix, property)
       vocab = Vocabs.fetch(prefix) do
-        vocab = RDF::Vocabulary.find do |vocab|
+        vocab = RDF::Vocabulary.detect do |vocab|
           unless vocab.__prefix__.is_a? RDF::URI
             Vocabs[vocab.__prefix__.to_s] = vocab
           end

data/lib/roadforest/graph/path-vocabulary.rb

@@ -0,0 +1,64 @@
+# This file generated automatically using vocab-fetch from path.ttl
+require 'rdf'
+module RDF
+  class RoadForest::Graph::Path < StrictVocabulary("http://judsonlester.info/rdf-vocab/path#")
+
+    # Class definitions
+    property :Literal
+    property :MultipleStep, :comment =>
+      %(A step that may appear more than once on a subject)
+    property :RepeatingStep, :comment =>
+      %(A step that repeats - the subject of a matching step become
+        the subject of a new match)
+    property :Root, :comment =>
+      %(The starting point of a path pattern)
+    property :Step, :comment =>
+      %(Base class for path steps)
+    property :Target, :comment =>
+      %(A target for the pattern)
+
+    # Property definitions
+    property :after, :comment =>
+      %(Constrains the matching of this literal to values that come
+        after the subject value in some order.)
+    property :before, :comment =>
+      %(Constrains the matching of this literal to values that come
+        before the subject value in some order.)
+    property :constraint, :comment =>
+      %(Description of constraints on values that can match this
+        Literal.)
+    property :defaultValue
+    property :forward, :comment =>
+      %(Indicates that the subject of the matched statement matches
+        the subject, and the predicate of the matched statement
+        matches the predicate.)
+    property :is, :comment =>
+      %(The target of this step has exactly this value.)
+    property :label
+    property :maxMulti, :comment =>
+      %(Limits the number of times a repeating step may repeat -
+        otherwise a repeating step is assumed to have no limit to
+        repetitions.)
+    property :maxRepeat, :comment =>
+      %(Limits the number of times a repeating step may repeat -
+        otherwise a repeating step is assumed to have no limit to
+        repetitions.)
+    property :minMulti, :comment =>
+      %(Limits the number of times a repeating step may repeat -
+        otherwise a repeating step is assumed allow 0 repetions.)
+    property :minRepeat, :comment =>
+      %(Limits the number of times a repeating step may repeat -
+        otherwise a repeating step is assumed allow 0 repetions.)
+    property :name
+    property :order, :comment =>
+      %(The subject resource describes the order in which to consider
+        values of this Literal.)
+    property :predicate, :comment =>
+      %(The property of a statement that matches this step)
+    property :reverse, :comment =>
+      %(Indicates that the subject of the matched statement matches
+        the predicate, and the predicate of the matched statement
+        matches the subject.)
+    property :type
+  end
+end

data/lib/roadforest/graph/post-focus.rb

@@ -5,6 +5,11 @@ module RoadForest::Graph
 
     attr_accessor :graphs
 
+    def initialize(access_manager, subject = nil)
+      super
+      @graphs = {}
+    end
+
     def dup
       other = super
       other.graphs = graphs

data/lib/roadforest/graph/vocabulary.rb

@@ -1,6 +1,8 @@
 require 'roadforest/graph'
 require 'rdf'
 
+require 'roadforest/graph/path-vocabulary'
+
 module RoadForest::Graph
   module Vocabulary
     class RF < ::RDF::Vocabulary("http://lrdesign.com/graph/roadforest#")
@@ -10,7 +12,7 @@ module RoadForest::Graph
     end
   end
 
-  class Af < ::RDF::StrictVocabulary("http://judsonlester.info/affordance#")
+  class Af < ::RDF::StrictVocabulary("http://judsonlester.info/rdf-vocab/affordance#")
 
     # Class definitions
     property :Affordance, :comment =>
@@ -57,6 +59,7 @@ module RoadForest::Graph
         the tokens be defreferenceable, and that they be accessible
         iff the user is authorized to activate the affordance in
         question.)
+    property :grants
     property :controlName, :comment =>
       %(Valid values are limited per application. Examples include
         'Media-Type', 'Encoding' or 'EntityTag')

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

@@ -15,6 +15,10 @@ module RoadForest
         Excon.new(site.to_s, @connection_defaults)
       end
 
+      def reset_connections
+        @connections.clear
+      end
+
       def site_connection(uri)
         uri = Addressable::URI.parse(uri)
         @connections[uri.normalized_site]

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

@@ -5,9 +5,10 @@ module RoadForest
   module HTTP
     class GraphTransfer
       attr_writer :type_handling
-      attr_accessor :user_agent
+      attr_accessor :user_agent, :trace
 
       def initialize(user_agent)
+        @trace = false
         @user_agent = user_agent
         @type_preferences = Hash.new{|h,k| k.nil? ? "*/*" : h[nil]}
       end
@@ -28,6 +29,8 @@ module RoadForest
         headers = {"Accept" => type_handling.parsers.types.accept_header}
         body = nil
 
+        trace_graph("OUT", graph)
+
         if(%w{POST PUT PATCH}.include? method.upcase)
           content_type = best_type_for(url)
           renderer = type_handling.choose_renderer(content_type)
@@ -49,6 +52,17 @@ module RoadForest
         retry
       end
 
+      def trace_graph(tag, graph)
+        return unless @trace
+        require 'rdf/turtle'
+        @trace = $stderr unless @trace.respond_to?(:puts)
+        @trace.puts "<#{tag}"
+        if graph.respond_to?(:dump)
+          @trace.puts graph.dump(:ntriples, :standard_prefixes => true, :prefixes => { "af" => "http://judsonlester.info/affordance#"})
+        end
+        @trace.puts "#{tag}>"
+      end
+
       def type_handling
         @type_handling || ContentHandling.rdf_engine
       end
@@ -67,6 +81,8 @@ module RoadForest
         parser = type_handling.choose_parser(response.headers["Content-Type"])
         graph = parser.to_graph(url, response.body_string)
 
+        trace_graph("IN", graph)
+
         response = GraphResponse.new(url, response)
         response.graph = graph
         return response

data/lib/roadforest/http/keychain.rb

@@ -3,76 +3,164 @@ 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
+    class BasicCredentials < Struct.new(:user, :secret)
+      def header_value
+        "Basic #{Base64.strict_encode64("#{user}:#{secret}")}"
+      end
+    end
+    YAML.add_tag("!basic", BasicCredentials)
+
+    class CredentialSource
+      def canonical_root(url)
+        url = Addressable::URI.parse(url)
+        url.path = "/"
+        url.to_s
+      end
+
+      # @returns {BasicCredentials}
+      # @returns nil to indicate no further credentials available
+      def respond_to_challenge(url, realm, attempt)
+        nil
+      end
+    end
+
+    class PreparedCredentialSource < CredentialSource
+      def initialize
+        @for_url = Hash.new{|h,k| h[k] = []}
+      end
+
+      def add(url, user, secret)
+        creds = BasicCredentials.new(user, secret)
+        add_credentials(url, creds)
       end
 
+      def add_credentials(url, creds)
+        @for_url[canonical_root(url)] << creds
+      end
+
+      def respond_to_challenge(url, realm, attempt)
+        @for_url[canonical_root(url)].fetch(attempt)
+      rescue IndexError
+        nil
+      end
+    end
+
+    #Manages user credentials for HTTP Basic auth
+    class Keychain
+      ATTEMPT_LIMIT = 5
       def initialize
         @realm_for_url = {}
         @with_realm = {}
+        @sources = []
+        @source_enums = Hash.new{|h,k| @sources.each}
+        @attempt_enums = Hash.new{|h,k| (0...ATTEMPT_LIMIT).each}
       end
 
-      def add(url, user, secret, realm=nil)
-        creds = Credentials.new(user, secret)
-        add_credentials(url, creds, realm || :default)
+      def add_source(source)
+        @sources << source
+        @source_enums.clear
+        @attempt_enums.clear
       end
 
-      def add_credentials(url, creds, realm)
-        if url.to_s[-1] != "/"
-          url << "/"
-        end
-        @realm_for_url[url.to_s] = realm
-
+      def canonical_root(url)
         url = Addressable::URI.parse(url)
         url.path = "/"
-        @with_realm[[url.to_s,realm]] = creds
+        url.fragment = nil
+        url.query = nil
+        url.to_s
+      end
+
+      def stripped_url(url)
+        url = Addressable::URI.parse(url)
+        url.fragment = nil
+        url.query = nil
+        url
       end
 
       BASIC_SCHEME = /basic\s+realm=(?<q>['"])(?<realm>(?:(?!['"]).)*)\k<q>/i
 
       def challenge_response(url, challenge)
+        url = stripped_url(url).to_s
+        #Future note: the RFC means that the creds selection mechanics are
+        #valid for all HTTP WWW-Authenticate reponses
         if (match = BASIC_SCHEME.match(challenge)).nil?
           return nil
         end
         realm = match[:realm]
+        @realm_for_url[url] = realm
 
-        response(url, realm)
+        cached_response(canonical_root(url), realm) || missing_credentials(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
+      def preemptive_response(url)
+        realm = realm_for_url(url)
+        url = canonical_root(url)
+        return cached_response(url, realm)
+      end
 
+      def cached_response(url, realm)
+        creds = credentials(url, realm)
         return nil if creds.nil?
-
         return creds.header_value
       end
 
+      def credentials_for(url)
+        realm = realm_for_url(url)
+        url = canonical_root(url)
+        credentials(url, realm)
+      end
+
+      def credentials(url, realm = nil)
+        @with_realm[[url, realm]]
+      end
+
       def missing_credentials(url, realm)
+        loop do
+          attempt = next_attempt(url, realm)
+          creds = current_source(url, realm).respond_to_challenge(url, realm, attempt)
+          if creds.nil?
+            next_source(url, realm)
+          else
+            @with_realm[[canonical_root(url), realm]] = creds
+            return creds.header_value
+          end
+        end
+        return nil
+      rescue StopIteration
         nil
       end
 
-      def preemptive_response(url)
-        url = Addressable::URI.parse(url)
+      def forget(url, realm)
+        @with_realm.delete([url, realm])
+      end
+
+      def current_source(url, realm)
+        @source_enums[[url, realm]].peek
+      end
+
+      def next_source(url, realm)
+        @attempt_enums.delete([url, realm])
+        @source_enums[[url, realm]].next
+      rescue StopIteration
+        @source_enums.delete([url, realm])
+        raise
+      end
 
+      def next_attempt(url, realm)
+        @attempt_enums[[url, realm]].next
+      rescue StopIteration
+        next_source(url, realm)
+        retry
+      end
+
+      def realm_for_url(url)
+        url = stripped_url(url)
         while (realm = @realm_for_url[url.to_s]).nil?
           new_url = url.join("..")
-          break if new_url == url
+          return realm if new_url == url
           url = new_url
         end
-
-        return response(url, realm)
+        return realm || :default
       end
     end
   end