roadforest 0.1 → 0.5

data/lib/roadforest/{rdf.rb → graph.rb}

@@ -1,6 +1,6 @@
 require 'rdf'
 
 module RoadForest
-  module RDF
+  module Graph
   end
 end

data/lib/roadforest/{rdf → graph}/access-manager.rb

@@ -1,17 +1,14 @@
 require 'rdf'
-require 'roadforest/rdf/resource-query'
-require 'roadforest/rdf/resource-pattern'
-require 'roadforest/rdf/normalization'
-require 'roadforest/rdf/parcel'
+require 'roadforest/graph/normalization'
 
-module RoadForest::RDF
+module RoadForest::Graph
   class ReadOnlyManager
     include ::RDF::Countable
     include ::RDF::Enumerable
     include ::RDF::Queryable
     include Normalization
 
-    attr_accessor :resource, :rigor, :source_graph
+    attr_accessor :resource, :source_graph
 
     def resource=(resource)
       @resource = normalize_context(resource)
@@ -20,7 +17,6 @@ module RoadForest::RDF
     def dup
       other = self.class.allocate
       other.resource = self.resource
-      other.rigor = self.rigor
       other.source_graph = self.source_graph
 
       return other
@@ -29,32 +25,28 @@ module RoadForest::RDF
     alias origin_graph source_graph
     alias destination_graph source_graph
 
+    def relevant_prefixes
+      relevant_prefixes_for_graph(origin_graph)
+    end
+
+    def each(&block)
+      origin_graph.each(&block)
+    end
+
     def build_query
-      ResourceQuery.new([], {}) do |query|
-        query.subject_context = resource
-        query.source_rigor = rigor
+      ::RDF::Query.new([], {}) do |query|
         yield query
       end
     end
 
-    def relevant_prefixes
-      relevant_prefixes_for_graph(origin_graph)
-    end
-
     def query_execute(query, &block)
-      query = ResourceQuery.from(query, resource, rigor)
       execute_search(query, &block)
     end
 
     def query_pattern(pattern, &block)
-      pattern = ResourcePattern.from(pattern, {:context_roles => {:subject => resource}, :source_rigor => rigor})
       execute_search(pattern, &block)
     end
 
-    def each(&block)
-      origin_graph.each(&block)
-    end
-
     def execute_search(search, &block)
       search.execute(origin_graph, &block)
     end
@@ -73,9 +65,6 @@ module RoadForest::RDF
     end
   end
 
-  class PostManager < WriteManager
-  end
-
   class SplitManager < WriteManager
     attr_accessor :target_graph
 
@@ -92,57 +81,6 @@ module RoadForest::RDF
     end
   end
 
-  class UpdateManager < SplitManager
-    def initialize
-      @copied_contexts = {}
-    end
-
-    attr_accessor :copied_contexts
-
-    def dup
-      other = super
-      other.copied_contexts = self.copied_contexts
-      return other
-    end
-
-    def execute_search(search, &block)
-      enum = search.execute(destination_graph)
-      if enum.any?{ true }
-        enum.each(&block)
-        return enum
-      end
-      search.execute(origin_graph, &block)
-    end
-
-    def insert(statement)
-      copy_context
-      super
-    end
-
-    def delete(statement)
-      copy_context
-      super
-    end
-
-    def parceller
-      @parceller ||=
-        begin
-          parceller = Parcel.new
-          parceller.graph = source_graph
-          parceller
-        end
-    end
-
-    def copy_context
-      return if copied_contexts[resource]
-      parceller.graph_for(resource).each_statement do |statement|
-        statement.context = resource
-        destination_graph << statement
-      end
-      copied_contexts[resource] = true
-    end
-  end
-
   class CopyManager < SplitManager
     def execute_search(search, &block)
       super(search) do |statement|

data/lib/roadforest/{rdf → graph}/document.rb

@@ -1,7 +1,7 @@
 require 'stringio'
 require 'roadforest'
 
-module RoadForest::RDF
+module RoadForest::Graph
   #Wrapper for text to be parsed into RDF
   class Document
     attr_accessor :content_type, :code, :source, :root_url, :body, :body_string

data/lib/roadforest/{rdf → graph}/etagging.rb

@@ -1,6 +1,6 @@
-require 'roadforest/rdf'
+require 'roadforest/graph'
 
-module RoadForest::RDF
+module RoadForest::Graph
   module Etagging
     def etag_from(graph)
       require 'openssl'

data/lib/roadforest/{rdf → graph}/focus-list.rb

@@ -1,18 +1,10 @@
 require 'rdf'
 
-require 'roadforest/rdf/resource-query'
-require 'roadforest/rdf/resource-pattern'
-
-module RoadForest::RDF
+module RoadForest::Graph
   class FocusList < ::RDF::List
 
     attr_accessor :root_url, :base_node
 
-    #XXX Can delete?
-    def source_rigor
-      graph.rigor
-    end
-
     alias car first
     alias cdr rest
 

data/lib/roadforest/{rdf → graph}/graph-copier.rb

@@ -1,8 +1,8 @@
 require 'rdf'
-require 'roadforest/rdf/graph-focus'
+require 'roadforest/graph/graph-focus'
 
 module RoadForest
-  module RDF
+  module Graph
     class GraphCopier < GraphFocus
       def query_value(query)
         #This isn't the most efficient way to do this (the query essentially

data/lib/roadforest/{rdf → graph}/graph-focus.rb

@@ -1,13 +1,11 @@
 require 'rdf'
 require 'rdf/model/node'
-require 'roadforest/rdf'
-require 'roadforest/rdf/focus-list'
-require 'roadforest/rdf/normalization'
-require 'roadforest/rdf/resource-query'
-require 'roadforest/rdf/access-manager'
+require 'roadforest/graph'
+require 'roadforest/graph/focus-list'
+require 'roadforest/graph/normalization'
+require 'roadforest/graph/access-manager'
 
-
-module RoadForest::RDF
+module RoadForest::Graph
   class NullFocus < ::BasicObject
     def initialize(focus, pattern, callsite)
       @focus, @pattern, @callsite = focus, pattern, callsite

data/lib/roadforest/{rdf → graph}/normalization.rb

@@ -1,7 +1,7 @@
 require 'addressable/uri'
 require 'rdf'
 
-module RoadForest::RDF
+module RoadForest::Graph
   module Normalization
     Vocabs = {}
     Vocabs["rdf"] = RDF

data/lib/roadforest/{rdf → graph}/post-focus.rb

@@ -1,6 +1,6 @@
-require 'roadforest/rdf/graph-focus'
+require 'roadforest/graph/graph-focus'
 
-module RoadForest::RDF
+module RoadForest::Graph
   class PostFocus < GraphFocus
 
     attr_accessor :graphs
@@ -14,7 +14,6 @@ module RoadForest::RDF
     def post_to
       graph = ::RDF::Graph.new
       access = WriteManager.new
-      access.rigor = access_manager.rigor
       access.source_graph = graph
       focus = GraphFocus.new(access, subject)
 

data/lib/roadforest/graph/vocabulary.rb

@@ -0,0 +1,96 @@
+require 'roadforest/graph'
+require 'rdf'
+
+module RoadForest::Graph
+  module Vocabulary
+    class RF < ::RDF::Vocabulary("http://lrdesign.com/graph/roadforest#")
+      property :Impulse
+      property :impulse
+      property :begunAt
+    end
+  end
+
+  class Af < ::RDF::StrictVocabulary("http://judsonlester.info/affordance#")
+
+    # Class definitions
+    property :Affordance, :comment =>
+      %(Base class for all affordances)
+    property :Control
+    property :Create, :comment =>
+      %(Triggering this affordance implies a request to create a new
+        resource)
+    property :Embed, :comment =>
+      %(A resource that should be properly displayed in-line rather
+        than provided as a hyperlink)
+    property :Idempotent, :comment =>
+      %(An affordance that will cause a change, but that can be
+        repeated without further hazard)
+    property :LiteralTemplate
+    property :Metadata, :comment =>
+      %(There is extra metadata available about this resource)
+    property :Mutate, :comment =>
+      %(Triggering this affordance expresses a desire to make changes
+        to a resource)
+    property :Navigate, :comment =>
+      %(A link to another resource. The assumption is that otherwise
+        undescribed URLs have a navigation affordance)
+    property :Null, :comment =>
+      %(The provided affordance is null. i.e. not dereferenceable, no
+        actions provided)
+    property :Remove, :comment =>
+      %(Triggering this affordance is a request to delete the resource)
+    property :ResourceTemplate
+    property :Safe, :comment =>
+      %(A safe affordance - it is asserted that no change will be
+        triggered by activating the affordance)
+    property :Unsafe, :comment =>
+      %(Affordances whose effects cannot be simply modeled and should
+        be triggered with care)
+    property :Update, :comment =>
+      %(Acting on this affordance will update the targeted resource.
+        Repeated updates will have not further effect)
+
+    # Property definitions
+    property :authorizedBy, :comment =>
+      %(Opaque descriptors of authorization tokens - resource can be
+        dereferenced by users with that token. It's recommended that
+        the tokens be defreferenceable, and that they be accessible
+        iff the user is authorized to activate the affordance in
+        question.)
+    property :controlName, :comment =>
+      %(Valid values are limited per application. Examples include
+        'Media-Type', 'Encoding' or 'EntityTag')
+    property :controlValue
+    property :controlledBy
+    property :defaultValue
+    property :label
+    property :name
+    property :objectTemplate, :comment =>
+      %(Used to indicate that a resource or literal template can be
+        used as the property in a statement)
+    property :pattern, :comment =>
+      %(An IRITemplate \(RFC 5xxx\) that defines how the template is
+        rendered - implicitly, all the parameters of the template are
+        provided as a key, value set called param_list, so something
+        like \(?param_list*\) should work like an HTML action=GET form)
+    property :payload
+    property :predicateTemplate, :comment =>
+      %(Used to indicate that a resource template can be used as the
+        property in a statement)
+    property :range
+    property :statement
+    property :subjectTemplate, :comment =>
+      %(Used to indicate that a resource template can be used as the
+        subject in a statement)
+    property :target, :comment =>
+      %(Could be a templated URL, or a URL resource. If not a
+        template, but the Affordance has one or more uriVariable
+        properties, the implication is that the target resource should
+        be used as the basis of a URI template by appending
+        \(?name,other,...\) to the URI.)
+    property :var, :comment =>
+      %(When the object is list, the members of the list should be
+        Parameters, the the list order implies the order in which the
+        parameters should be used)
+  end
+end

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

@@ -1,5 +1,5 @@
 require 'roadforest/http'
-require 'roadforest/content-handling/engine'
+require 'roadforest/content-handling/common-engines'
 
 module RoadForest
   module HTTP
@@ -50,7 +50,7 @@ module RoadForest
       end
 
       def type_handling
-        @type_handling ||= ContentHandling::Engine.default
+        @type_handling || ContentHandling.rdf_engine
       end
 
       def best_type_for(url)

data/lib/roadforest/interface/application.rb

@@ -0,0 +1,145 @@
+require 'roadforest/source-rigor/graph-store'
+require 'roadforest/graph/etagging'
+require 'roadforest/graph/access-manager'
+require 'roadforest/graph/graph-focus'
+
+module RoadForest
+  module Interface
+    class ProcessingSequenceError < StandardError
+    end
+
+    class Application
+      def initialize(route_name, params, router, services)
+        @route_name = route_name
+        @params = params
+        @router = router
+        @services = services
+        @data = nil
+        @response_values = {}
+      end
+      attr_reader :route_name, :params, :services, :data, :router
+      attr_reader :response_values
+
+      #@!group Utility methods
+
+      def path_for(route_name = nil, params = nil)
+        router.path_for(route_name, params || self.params)
+      end
+
+      def url_for(route_name, params = nil)
+        Addressable::URI.parse(canonical_host.to_s).join(path_for(route_name, params))
+      end
+
+      def interface_for(route_name = nil, params = nil)
+        router.interface_for(route_name, params || self.params)
+      end
+
+      def canonical_uri
+        url_for(route_name, params)
+      end
+
+      def my_path
+        path_for(route_name, params)
+      end
+
+      def my_url
+        canonical_uri.to_s
+      end
+
+      #@!endgroup
+
+      #@!group Authorization
+
+      def required_grants(method)
+        services.authz.build_grants do |grants|
+          grants.add(:admin)
+        end
+      end
+
+      def authorization(method, header)
+        required = required_grants(method)
+        if required.empty?
+          :public
+        else
+          services.authz.authorization(header, required_grants(method))
+        end
+      end
+
+      def authentication_challenge
+        services.authz.challenge(:realm => "Roadforest")
+      end
+
+      #@!endgroup
+
+      def canonical_host
+        services.canonical_host
+      end
+
+      def reset #XXX remove?
+      end
+
+      #group Resource interface
+
+      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
+  end
+end