roadforest 0.0.2 → 0.0.3

data/examples/file-management.rb

@@ -56,7 +56,7 @@ module FileManagementExample
         end
 
         def add_child(graph)
-          services.logger.debug(graph.source_graph.dump(:nquads))
+          services.logger.debug(graph.access_manager.source_graph.dump(:nquads))
           new_file = FileRecord.new(graph.first(:lc, "name"), false)
           services.file_records << new_file
         end
@@ -65,6 +65,12 @@ module FileManagementExample
           graph.add_list(:lc, "needs") do |list|
             services.file_records.each do |record|
               if !record.resolved
+#                need = copy_from(:need, '*' => record.name)
+#                list.add_node(need.url) do |node|
+#                  need.target = node
+#                  need[:lc, :name]
+#                  need[:lc, :digest]
+#                end
                 list << path_for(:need, '*' => record.name)
               end
             end

data/lib/roadforest/application.rb

@@ -3,7 +3,6 @@ module RoadForest
   class Application < Webmachine::Application; end
 end
 
-require 'roadforest/resource/handlers'
 require 'roadforest/application/dispatcher'
 require 'roadforest/application/path-provider'
 require 'roadforest/application/services-host'
@@ -14,7 +13,6 @@ require 'roadforest/rdf/normalization'
 module RoadForest
   class Application
     include RDF::Normalization
-    include Resource::Handlers
 
     def initialize(canonical_host, services = nil, configuration = nil, dispatcher = nil)
       @canonical_host = normalize_resource(canonical_host)

data/lib/roadforest/application/dispatcher.rb

@@ -1,8 +1,8 @@
 require 'webmachine'
+require 'roadforest/application/route-adapter'
 
 module RoadForest
   class Dispatcher < Webmachine::Dispatcher
-    include Resource::Handlers
     def initialize(services)
       super(method(:create_resource))
       @services = services
@@ -11,6 +11,25 @@ module RoadForest
     end
     attr_accessor :services, :trace_by_default
 
+    def bundle(resource_class, &block)
+      Application::RouteAdapter.new(resource_class, &block)
+    end
+
+    def bundle_typed_resource(resource_type, model_class, route_name)
+      resource_class = Resource.get(resource_type)
+      bundle(resource_class) do |resource, request, response|
+        resource.model = model_class.new(route_name, resource.params, services)
+      end
+    end
+
+    def bundle_traced_resource(resource_type, model_class, route_name)
+      resource_class = Resource.get(resource_type)
+      bundle(resource_class) do |resource, request, response|
+        resource.model = model_class.new(route_name, resource.params, services)
+        resource.trace = true
+      end
+    end
+
     def resource_route(resource, name, path_spec, bindings)
       route = Route.new(path_spec, resource, bindings || {})
       yield route if block_given?

data/lib/roadforest/model.rb

@@ -133,9 +133,9 @@ module RoadForest
     end
 
     def start_focus(graph, resource_url=nil)
-      focus = RDF::GraphFocus.new
-      focus.graph = graph
-      focus.subject = resource_url || my_url
+      access = RDF::WriteManager.new
+      access.source_graph = graph
+      focus = RDF::GraphFocus.new(access, resource_url || my_url)
 
       yield focus if block_given?
       return focus
@@ -158,7 +158,7 @@ module RoadForest
       graph = ::RDF::Graph.new
       focus = start_focus(graph, my_url)
       fill_graph(focus)
-      self.response_data = focus.graph
+      self.response_data = graph
     end
   end
 end

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

@@ -2,19 +2,16 @@ require 'rdf'
 require 'roadforest/rdf/resource-query'
 require 'roadforest/rdf/resource-pattern'
 require 'roadforest/rdf/normalization'
+require 'roadforest/rdf/parcel'
 
 module RoadForest::RDF
-  class ContextFascade
+  class ReadOnlyManager
     include ::RDF::Countable
     include ::RDF::Enumerable
     include ::RDF::Queryable
     include Normalization
 
-    attr_accessor :resource, :rigor, :source_graph, :target_graph, :copied_contexts
-
-    def initialize
-      @copied_contexts = {}
-    end
+    attr_accessor :resource, :rigor, :source_graph
 
     def resource=(resource)
       @resource = normalize_context(resource)
@@ -24,33 +21,14 @@ module RoadForest::RDF
       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
+    alias origin_graph source_graph
+    alias destination_graph source_graph
 
-    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
@@ -59,6 +37,10 @@ module RoadForest::RDF
       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)
@@ -69,32 +51,104 @@ module RoadForest::RDF
       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)
+    def each(&block)
+      origin_graph.each(&block)
     end
 
-    def each(&block)
-      source_graph.each(&block)
+    def execute_search(search, &block)
+      search.execute(origin_graph, &block)
     end
+  end
 
+  class WriteManager < ReadOnlyManager
     def insert(statement)
-      copy_context
       statement[3] = resource
-      target_graph.insert(statement)
+      destination_graph.insert(statement)
     end
 
     def delete(statement)
       statement = RDF::Query::Pattern.from(statement)
       statement.context = resource
+      destination_graph.delete(statement)
+    end
+  end
+
+  class PostManager < WriteManager
+  end
+
+  class SplitManager < WriteManager
+    attr_accessor :target_graph
+
+    alias destination_graph target_graph
+
+    def dup
+      other = super
+      other.target_graph = self.target_graph
+      return other
+    end
+
+    def relevant_prefixes
+      super.merge(relevant_prefixes_for_graph(destination_graph))
+    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
-      target_graph.delete(statement)
+      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|
+        destination_graph.insert(statement)
+        yield statement
+      end
     end
   end
 end

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

@@ -37,7 +37,7 @@ module RoadForest::RDF
 
       if empty?
         new_subject = subject
-        graph.insert([new_subject, RDF.type, RDF.List])
+        #graph.insert([new_subject, RDF.type, RDF.List])
       else
         old_subject, new_subject = last_subject, RDF::Node.new
         graph.delete([old_subject, RDF.rest, RDF.nil])

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

@@ -3,12 +3,17 @@ require 'roadforest/rdf/graph-focus'
 
 module RoadForest
   module RDF
-    class GraphCopier < GraphWriting
-      attr_accessor :target_graph
-
-      def initialize
+    class GraphCopier < GraphFocus
+      def query_value(query)
+        #This isn't the most efficient way to do this (the query essentially
+        #happens twice) but the intended use of GC is to copy small numbers of
+        #patterns between small graphs, so the n is small
+        query.patterns.each do |pattern|
+          pattern.execute(@access_manager) do |statement|
+            @access_manager.insert(statement)
+          end
+        end
         super
-        @target_graph = ::RDF::Graph.new
       end
     end
   end

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

@@ -1,39 +1,94 @@
 require 'rdf'
-require 'roadforest/rdf/context-fascade'
-require 'roadforest/rdf/graph-reading'
+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'
+
 
 module RoadForest::RDF
-  class GraphCollection
-    include Enumerable
+  class NullFocus < ::BasicObject
+    def initialize(focus, pattern, callsite)
+      @focus, @pattern, @callsite = focus, pattern, callsite
+    end
+
+    def __callsite__
+      @callsite
+    end
+
+    def subject
+      @focus.subject
+    end
+
+    def nil?
+      true
+    end
+
+    def blank?
+      true
+    end
+
+    def empty?
+      true
+    end
+
+    def length
+      0
+    end
+    alias count length
+    alias size length
+
+    def method_missing(method, *args, &block)
+      ::Kernel.raise ::NoMethodError, "No method '#{method}' on NullFocus. " +
+        "NullFocus returned because there were no results at \n#{@focus.subject}\n  for \n#{@pattern.inspect}\n" +
+        "Search was attempted at #{@callsite[0]}"
+    end
   end
 
-  class MultivaluedProperty < GraphCollection
-    attr_reader :graph, :subject, :property
-    def initialize(graph, subject, property)
-      @graph, @subject, @propery = graph, subject, property
+  class GraphFocus
+    #XXX Any changes to this class heirarchy or to ContextFascade should start
+    #with a refactor like:
+    #  Reduce this to the single-node API ([] []=)
+    #  Change the ContextFascade into a family of classes (RO, RW, Update)
+    include Normalization
+
+    #attr_accessor :source_graph, :target_graph, :subject, :root_url,
+    #:source_rigor
+
+    attr_accessor :subject, :access_manager
+
+    alias rdf subject
+
+    def initialize(access_manager, subject = nil)
+      @access_manager = access_manager
+      self.subject = subject unless subject.nil?
     end
 
-    def values
-      query_value(graph, subject, property)
+    def root_url
+      @access_manager.resource
     end
 
-    def each
-      if block_given?
-        other
-        values.each do |value|
-          yield unwrap_value(value)
-        end
-      else
-        values.each
+    def subject=(*value)
+      @subject = normalize_resource(value)
+      case @subject
+      when ::RDF::URI
+        @access_manager.resource = @subject
       end
     end
 
-    def add(value)
-      add_statement(subject, property, value)
+    def inspect
+      "#<#{self.class.name}:0x#{"%x" % object_id} (#{subject.to_s}) #{forward_properties.inspect}>"
+    end
+    alias to_s inspect
+
+    def dup
+      other = self.class.new(access_manager.dup)
+      other.subject = subject
+      other
     end
-  end
 
-  class GraphWriting < GraphReading
+    ### Begin old GraphFocus
     def normalize_triple(property, value, extra=nil)
       if not extra.nil?
         property = [property, value]
@@ -71,6 +126,7 @@ module RoadForest::RDF
       end
       value
     end
+    alias first_or_add find_or_add
 
     def set_node(property, url=nil)
       create_node(url) do |node|
@@ -100,20 +156,154 @@ module RoadForest::RDF
       yield list if block_given?
       return list
     end
-  end
+    #### End of old GraphFocus
+
+    def wrap_node(value)
+      next_step = dup
+      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
+    end
+
+    def unwrap_value(value)
+      return nil if value.nil?
+      if value.respond_to? :object
+        value.object
+      else
+        wrap_node(value)
+      end
+    end
+
+    def to_context
+      normalize_context(subject)
+    end
+
+    def root_url=(*value) #XXX curies?
+      @root_url = normalize_resource(value)
+    end
 
-  class GraphFocus < GraphWriting
-    def target_graph
-      @access_manager.target_graph
+    #XXX This probably wants to be handled completely in the MediaType handler
+    def relevant_prefixes
+      access_manager.relevant_prefixes
     end
 
-    def source_graph=(graph)
-      @access_manager.source_graph = graph
-      @access_manager.target_graph = graph
+    def get(prefix, property = nil)
+      return maybe_null( prefix, property,
+        single_or_enum(forward_query_value( prefix, property))
+      )
     end
-    alias target_graph= source_graph=
+    alias_method :[], :get
 
-    alias graph source_graph
-    alias graph= source_graph=
+    def first(prefix, property = nil)
+      return maybe_null( prefix, property,
+        forward_query_value( prefix, property ).first
+      )
+    end
+
+    def all(prefix, property = nil)
+      return  maybe_null( prefix, property,
+        forward_query_value( prefix, property )
+      )
+    end
+
+    #XXX Maybe rev should return a decorator, so it looks like:
+    #focus.rev.get(...) or focus.rev.all(...)
+    def rev(prefix, property = nil)
+      return maybe_null( prefix, property,
+        single_or_enum(reverse_query_value( prefix, property))
+      )
+    end
+
+    def rev_first(prefix, property = nil)
+      return maybe_null( prefix, property,
+        reverse_query_value(prefix, property).first
+      )
+    end
+
+    def rev_all(prefix, property = nil)
+      return maybe_null( prefix, property,
+        reverse_query_value(prefix, property)
+      )
+    end
+
+    def as_list
+      list = FocusList.new(subject, access_manager)
+      list.base_node = self
+      list
+    end
+
+    def forward_properties
+      query_properties( build_query{|q| q.pattern([ normalize_resource(subject), :property, :value ])} )
+    end
+
+    def reverse_properties
+      query_properties( build_query{|q| q.pattern([ :value, :property, normalize_resource(subject)])} )
+    end
+
+    protected
+
+    STRIP_TRACE = %r{\A#{File::expand_path("../../..", __FILE__)}}
+    def maybe_null(prefix, property, result)
+      if not result.nil?
+        if result.respond_to? :empty?
+          return result unless result.empty?
+        else
+          return result
+        end
+      end
+      return NullFocus.new(self, normalize_property(prefix, property), caller(0).drop_while{|line| line =~ STRIP_TRACE})
+    end
+
+    def single_or_enum(values)
+      case values.length
+      when 0
+        return nil
+      when 1
+        return values.first
+      else
+        return values.enum_for(:each)
+      end
+    end
+
+    def reverse_query_value(prefix, property=nil)
+      query_value(build_query{|q|
+        q.pattern([ :value, normalize_property(prefix, property), normalize_resource(subject)])
+      })
+    end
+
+    def forward_query_value(prefix, property=nil)
+      query_value(build_query{|q|
+        q.pattern([ normalize_resource(subject), normalize_property(prefix, property), :value])
+      })
+    end
+
+    def build_query(&block)
+      access_manager.build_query(&block)
+    end
+
+    def execute_query(query)
+      query.execute(access_manager)
+    end
+
+    def query_value(query)
+      solutions = execute_query(query)
+      solutions.map do |solution|
+        unwrap_value(solution.value)
+      end
+    end
+
+    def query_properties(query)
+      Hash[execute_query(query).map do |solution|
+        prop = solution.property
+        if qname = prop.qname
+          prop = qname
+        end
+        [prop, solution.value]
+      end]
+    end
   end
 end