roadforest 0.0.1 → 0.0.2

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

@@ -1,19 +1,61 @@
-require 'roadforest/rdf/focus-wrapping'
-require 'roadforest/rdf/normalization'
+require 'rdf'
+
+require 'roadforest/rdf/resource-query'
+require 'roadforest/rdf/resource-pattern'
+
 module RoadForest::RDF
   class FocusList < ::RDF::List
-    include Normalization
 
-    attr_accessor :root_url, :base_node, :source_rigor
+    attr_accessor :root_url, :base_node
+
+    #XXX Can delete?
+    def source_rigor
+      graph.rigor
+    end
+
+    alias car first
+    alias cdr rest
 
     def first
-      base_node.unwrap_value(super)
+      at(0)
     end
 
     def each
+      return to_enum unless block_given?
       super do |value|
         yield base_node.unwrap_value(value)
       end
     end
+
+    def append(value)
+      value = case value
+        when nil         then RDF.nil
+        when RDF::Value  then value
+        when Array       then RDF::List.new(nil, graph, value)
+        else value
+      end
+
+      if empty?
+        new_subject = subject
+        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])
+        graph.insert([old_subject, RDF.rest, new_subject])
+      end
+
+      graph.insert([new_subject, RDF.first, value.is_a?(RDF::List) ? value.subject : value])
+      graph.insert([new_subject, RDF.rest, RDF.nil])
+
+      self
+    end
+    alias << append
+
+    def append_node(subject=nil)
+      base_node.create_node(subject) do |node|
+        append(node.subject)
+        yield node if block_given?
+      end
+    end
   end
 end

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

@@ -3,13 +3,12 @@ require 'roadforest/rdf/graph-focus'
 
 module RoadForest
   module RDF
-    class GraphCopier < GraphFocus
-      attr_accessor :source_graph, :subject
-
-      alias target_graph graph
+    class GraphCopier < GraphWriting
+      attr_accessor :target_graph
 
       def initialize
-        @graph = ::RDF::Graph.new
+        super
+        @target_graph = ::RDF::Graph.new
       end
     end
   end

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

@@ -1,6 +1,5 @@
 require 'rdf'
 require 'roadforest/rdf/context-fascade'
-require 'roadforest/rdf/focus-wrapping'
 require 'roadforest/rdf/graph-reading'
 
 module RoadForest::RDF
@@ -34,7 +33,7 @@ module RoadForest::RDF
     end
   end
 
-  module GraphWriting
+  class GraphWriting < GraphReading
     def normalize_triple(property, value, extra=nil)
       if not extra.nil?
         property = [property, value]
@@ -55,41 +54,66 @@ module RoadForest::RDF
     def add(property, value, extra=nil)
       property, value = normalize_triple(property, value, extra)
 
-      target_graph.insert([subject, property, value])
+      access_manager.insert([subject, property, value])
       return value
     end
 
     def delete(property, extra=nil)
-      target_graph.delete([subject, normalize_property(property, extra), :value])
+      access_manager.delete(:subject => subject, :predicate => normalize_property(property, extra))
+    end
+
+    def find_or_add(property, url=nil, &block)
+      value = first(property)
+      if value.nil?
+        value = add_node(property, url, &block)
+      else
+        yield value if block_given?
+      end
+      value
     end
 
     def set_node(property, url=nil)
-      node = wrap_node(set(property, normalize_resource(url) || RDF::Node.new))
-      yield node if block_given?
-      node
+      create_node(url) do |node|
+        set(property, node.subject)
+        yield node if block_given?
+      end
     end
     alias node_at set_node
 
     def add_node(property, url=nil)
-      node = wrap_node(add(property, normalize_resource(url) || RDF::Node.new))
+      create_node(url) do |node|
+        add(property, node.subject)
+        yield node if block_given?
+      end
+    end
+
+    #Create a subject node without relationship to the rest of the graph
+    def create_node(url=nil)
+      node = wrap_node(normalize_resource(url))
       yield node if block_given?
       node
     end
 
     def add_list(property, extra=nil)
-      list = ::RDF::List.new(nil, target_graph)
-      target_graph.insert([subject, normalize_property(property, extra), list.subject])
+      list = FocusList.new(nil, access_manager)
+      access_manager.insert([subject, normalize_property(property, extra), list.subject])
       yield list if block_given?
       return list
     end
   end
 
-  class GraphFocus < GraphReading
-    include GraphWriting
-
+  class GraphFocus < GraphWriting
     def target_graph
-      graph
+      @access_manager.target_graph
+    end
+
+    def source_graph=(graph)
+      @access_manager.source_graph = graph
+      @access_manager.target_graph = graph
     end
+    alias target_graph= source_graph=
 
+    alias graph source_graph
+    alias graph= source_graph=
   end
 end

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

@@ -1,69 +1,113 @@
 require 'roadforest/rdf/focus-list'
 require 'roadforest/rdf/normalization'
-require 'roadforest/rdf/focus-wrapping'
 require 'roadforest/rdf/resource-query'
+require 'rdf/model/node'
+require 'roadforest/rdf'
+
 
 module RoadForest::RDF
   class GraphReading
+    #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
-    include FocusWrapping
 
-    attr_accessor :graph, :subject, :root_url, :source_rigor
+    #attr_accessor :source_graph, :target_graph, :subject, :root_url,
+    #:source_rigor
+
+    attr_accessor :subject, :access_manager
+
     alias rdf subject
 
     def initialize(subject = nil, graph = nil, rigor = nil)
-      @graph = nil
-      @subject = nil
-      @root_url = nil
-      @source_rigor = nil
+      @access_manager = ContextFascade.new
+      @access_manager.rigor = rigor
+      self.target_graph = graph
+      self.source_graph = graph
+
       self.subject = subject unless subject.nil?
-      self.graph = graph unless graph.nil?
-      self.source_rigor = rigor unless rigor.nil?
     end
 
-    def inspect
-      "#<#{self.class.name}:0x#{"%x" % object_id} (#{subject.to_s}) #{forward_properties.inspect}>"
+    def source_graph
+      @access_manager.source_graph
     end
 
-    def dup
-      other = self.class.new
-      other.graph = graph
-      other.subject = subject
-      other.root_url = root_url
-      other.source_rigor = source_rigor
-      other
+    def source_graph=(graph)
+      @access_manager.source_graph = graph
     end
 
-    def to_context
-      normalize_context(subject)
+    def target_graph
+      nil
     end
 
-    def root_url=(*value) #XXX curies?
-      @root_url = normalize_resource(value)
+    def target_graph=(graph)
+      @access_manager.target_graph = nil
+    end
+
+    def source_rigor
+      @access_manager.rigor
+    end
+
+    def source_rigor=(rigor)
+      @access_manager.rigor = rigor
+    end
+
+    def root_url
+      @access_manager.resource
     end
 
     def subject=(*value)
       @subject = normalize_resource(value)
       case @subject
       when ::RDF::URI
-        @root_url ||= @subject
+        @access_manager.resource = @subject
       end
     end
 
-    def build_query
-      ResourceQuery.new([], {}) do |query|
-        query.subject_context = @root_url
-        query.source_rigor = @source_rigor
-        yield query
+    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
+      other.access_manager = access_manager.dup
+      other.subject = subject
+      other
+    end
+
+    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 forward_properties
-      query_properties( build_query{|q| q.pattern([ normalize_resource(subject), :property, :value ])} )
+    def unwrap_value(value)
+      return nil if value.nil?
+      if value.respond_to? :object
+        value.object
+      else
+        wrap_node(value)
+      end
     end
 
-    def reverse_properties
-      query_properties( build_query{|q| q.pattern([ :value, :property, normalize_resource(subject)])} )
+    def to_context
+      normalize_context(subject)
+    end
+
+    def root_url=(*value) #XXX curies?
+      @root_url = normalize_resource(value)
+    end
+
+    #XXX This probably wants to be handled completely in the MediaType handler
+    def relevant_prefixes
+      relevant_prefixes_for_graph(source_graph)
     end
 
     def get(prefix, property = nil)
@@ -94,15 +138,32 @@ module RoadForest::RDF
     end
 
     def as_list
-      graph = ContextFascade.new(@graph, @root_url, @source_rigor)
-      list = FocusList.new(@subject, graph)
+      list = FocusList.new(subject, access_manager)
       list.base_node = self
-      list.source_rigor = source_rigor
       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
 
+    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)])
@@ -115,25 +176,19 @@ module RoadForest::RDF
       })
     end
 
+    def build_query(&block)
+      access_manager.build_query(&block)
+    end
+
     def query_value(query)
-      solutions = query.execute(graph)
+      solutions = query.execute(access_manager)
       solutions.map do |solution|
         unwrap_value(solution.value)
       end
     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 query_properties(query)
-      Hash[query.execute(graph).map do |solution|
+      Hash[query.execute(access_manager).map do |solution|
         prop = solution.property
         if qname = prop.qname
           prop = qname

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

@@ -25,26 +25,27 @@ module RoadForest::RDF
       @repository = repo || RDF::Repository.new
       @local_context_node = RDF::Node.new(:local)
       @debug_io = nil
-      next_impulse
+      force_impulse
       yield self if block_given?
     end
 
-    def next_impulse
-      return if !@current_impulse.nil? and raw_quiet_impulse?
-      #mark ended?
-      #chain impulses?
+    def force_impulse
       @current_impulse = RDF::Node.new
       repository.insert(normalize_statement(@current_impulse, [:rdf, 'type'], [:rf, 'Impulse'], nil))
       repository.insert(normalize_statement(@current_impulse, [:rf, 'begunAt'], Time.now, nil))
     end
 
-    def quiet_impulse?
-      raw_quiet_impulse?
+    def next_impulse
+      return if quiet_impulse?
+      force_impulse
+      #mark ended?
+      #chain impulses?
     end
 
-    def raw_quiet_impulse?
+    def quiet_impulse?
       repository.query([nil, nil, @current_impulse, false]).to_a.empty?
     end
+    alias raw_quiet_impulse? quiet_impulse?
 
     #repo cleanup - expired graphs
 
@@ -130,6 +131,8 @@ module RoadForest::RDF
     end
 
     def insert_statement(statement)
+      #puts "\n#{__FILE__}:#{__LINE__} => #{[self.object_id,
+      #statement].inspect}"
       repository.insert(statement)
 
       repository.delete([statement.context, expand_curie([:rf, "impulse"]), nil])
@@ -158,6 +161,7 @@ module RoadForest::RDF
       end
 
       @repository.query(query) do |statement|
+        next if statement.context.nil?
         yield statement
       end
     end

data/lib/roadforest/rdf/investigation.rb

@@ -28,7 +28,6 @@ module RoadForest::RDF
       source_rigor.graph_transfer.make_request(method, url, graph)
     end
 
-
     def insert_graph(context, graph)
       queryable.insert_graph(context, graph)
     end

data/lib/roadforest/rdf/normalization.rb

@@ -9,7 +9,9 @@ module RoadForest::RDF
       subject = normalize_resource(subject) || RDF::Node.new
       predicate = normalize_uri(predicate)
       object = normalize_term(object) || RDF::Node.new
-      context = normalize_resource(context)
+      unless context.nil?
+        context = normalize_resource(context)
+      end
 
       RDF::Statement.new(subject, predicate, object, :context => context)
     end
@@ -23,6 +25,7 @@ module RoadForest::RDF
       from = expand_curie(from)
       case from
       when nil
+        from = RDF::Node.new
       when RDF::Resource
       when /^_:/
         from = RDF::Resource.new(from)
@@ -72,16 +75,47 @@ module RoadForest::RDF
       RDF::Literal.new(object)
     end
 
+    def relevant_prefixes_for_graph(graph)
+      Hash[ vocabularies_in_graph(graph).map do |prefix|
+        vocab = Vocabs[prefix]
+        [prefix, vocab.to_uri]
+      end]
+    end
+
+    def vocabularies_in_graph(graph)
+      patterns = Vocabs.map do |prefix, vocab|
+        [%r{^#{vocab.to_uri}}, prefix]
+      end
+
+      vocabs = {}
+
+      graph.each_statement do |statement|
+        statement.to_a.each do |field|
+          next unless RDF::URI === field
+          field = field.to_s
+          patterns.each do |pattern, vocab|
+            if pattern =~ field
+              vocabs[vocab] = true
+            end
+          end
+        end
+      end
+
+      vocabs.keys
+    end
+
     def expand_curie_pair(prefix, property)
       vocab = Vocabs.fetch(prefix) do
         vocab = RDF::Vocabulary.find do |vocab|
+          unless vocab.__prefix__.is_a? RDF::URI
+            Vocabs[vocab.__prefix__.to_s] = vocab
+          end
           vocab.__prefix__.to_s == prefix
         end
         #p k => vocab #ok
         if vocab.nil?
           raise "Don't know a vocabulary for prefix #{prefix.inspect} in CURIE #{prefix}:#{property}"
         end
-        Vocabs[prefix] = vocab
         vocab
       end
       vocab[property]
@@ -126,7 +160,6 @@ module RoadForest::RDF
     end
 
     def interned_uri(value)
-
       RDF::URI.intern(uri(value))
     end
 
@@ -140,8 +173,8 @@ module RoadForest::RDF
       if !value.query.nil? and value.query.empty?
         value.query = nil
       end
-      value.validate!
       value.canonicalize!
+      value.validate!
 
       value
     end

data/lib/roadforest/rdf/resource-pattern.rb

@@ -1,5 +1,6 @@
 require 'rdf/query/pattern'
 require 'roadforest/rdf'
+require 'roadforest/rdf/graph-store'
 require 'roadforest/rdf/investigation'
 
 module RoadForest::RDF

data/lib/roadforest/rdf/source-rigor/credence-annealer.rb

@@ -12,6 +12,8 @@ class RoadForest::RDF::SourceRigor
     def resolve(&block)
       attempts = @attempts
 
+      @graph.force_impulse
+
       begin
         raise "Annealing failed after #@attempts attempts" if (attempts -= 1) < 0
         @graph.next_impulse

data/lib/roadforest/rdf/source-rigor/http-investigator.rb

@@ -1,20 +1,18 @@
 require 'roadforest/rdf/source-rigor/investigator'
-class RoadForest::RDF::SourceRigor
-  class HTTPInvestigator < Investigator
-    register :http
+module RoadForest
+  class RDF::SourceRigor
+    class HTTPInvestigator < Investigator
+      register :http
 
-    def pursue(investigation)
-      response = investigation.make_request("GET", investigation.context_roles[:subject])
-      case response.status
-      when (200..299)
-        investigation.insert_graph(response.url, response.graph)
-      when (300..399)
-        #client should follow redirects
-      when (400..499)
-      when (500..599)
-        raise NotCredible #hrm
+      def pursue(investigation)
+        response = investigation.make_request("GET", investigation.context_roles[:subject])
+        case response
+        when HTTP::GraphResponse
+          investigation.insert_graph(response.url, response.graph)
+        when HTTP::UnparseableResponse
+          #Do nothing
+        end
       end
-    rescue NotCredible
     end
   end
 end

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

@@ -2,72 +2,17 @@ require 'roadforest/rdf/graph-focus'
 require 'roadforest/rdf/parcel'
 
 module RoadForest::RDF
-  class UpdateFocus < GraphFocus
-    attr_accessor :target_graph
-
-    alias source_graph= graph=
-    alias source_graph graph
-
-    def dup
-      other = super
-      other.target_graph = target_graph
-      other
-    end
-
-    def parceller
-      @parceller ||=
-        begin
-          parceller = Parcel.new
-          parceller.graph = source_graph
-          parceller
-        end
+  class UpdateFocus < GraphWriting
+    def target_graph
+      @access_manager.target_graph
     end
 
-    def copy_context
-      unless target_graph.has_context?(root_url)
-        parceller.graph_for(root_url).each_statement do |statement|
-          statement.context = root_url
-          target_graph << statement
-        end
-      end
-    end
-
-    def add(property, value, extra=nil)
-      copy_context
-      property, value = normalize_triple(property, value, extra)
-      target_graph.insert([subject, property, value, root_url])
-    end
-
-    def set(property, value, extra=nil)
-      copy_context
-      super
-    end
-
-    def delete(property, extra=nil)
-      copy_context
-      property, value = normalize_triple(property, value, extra)
-      target_graph.query([subject, property]) do |statement|
-        target_graph.delete(statement)
-      end
-    end
-
-    def query_value(query)
-      source_result = super
-      target_result = query.execute(target_graph).map do |solution|
-        unwrap_value(solution.value)
-      end
-
-      if target_result.empty?
-        source_result
-      else
-        target_result
-      end
+    def target_graph=(graph)
+      @access_manager.target_graph = graph
     end
 
-    def wrap_node(value)
-      focus = super
-      focus.target_graph = self.target_graph
-      focus
+    def relevant_prefixes
+      super.merge(relevant_prefixes_for_graph(target_graph))
     end
   end
 end