roadforest 0.0.2 → 0.0.3

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

@@ -1,5 +1,4 @@
 require 'rdf'
-require 'roadforest/rdf/graph-focus'
 require 'roadforest/rdf/vocabulary'
 require 'roadforest/rdf/normalization'
 
@@ -47,8 +46,6 @@ module RoadForest::RDF
     end
     alias raw_quiet_impulse? quiet_impulse?
 
-    #repo cleanup - expired graphs
-
     def reader_for(content_type, repository)
       RDF::Reader.for(content_type)
     end
@@ -100,15 +97,7 @@ module RoadForest::RDF
       end
       #puts; puts "#{__FILE__}:#{__LINE__} => \n#{(graph_dump(:nquads))}"
     end
-
-    def insert_graph(context, graph)
-      context = normalize_context(context)
-      delete_statements(:context => context)
-      graph.each_statement do |statement|
-        statement.context = context
-        record_statement(statement)
-      end
-    end
+    alias insert_graph insert_reader
 
     def add_statement(*args)
       case args.length

data/lib/roadforest/rdf/investigation.rb

@@ -74,7 +74,9 @@ module RoadForest::RDF
     end
 
     def results_for_context(context)
-      results.find_all{|item| item.context == context}
+      results.find_all do |item|
+        item.context == context
+      end
     end
 
     #XXX Do we need the nil result if context_metadata is empty?

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

@@ -2,10 +2,7 @@ require 'roadforest/rdf/graph-focus'
 
 module RoadForest::RDF
   class PostFocus < GraphFocus
-    def initialize(subject = nil, graph = nil , rigor = nil)
-      super(subject, graph, rigor)
-      @graphs = {}
-    end
+
     attr_accessor :graphs
 
     def dup
@@ -14,22 +11,17 @@ module RoadForest::RDF
       other
     end
 
-    def graph_transfer
-      source_rigor.graph_transfer
-    end
-
     def post_to
       graph = ::RDF::Graph.new
-      focus = GraphFocus.new(subject, graph, source_rigor) #XXX non-client version
+      access = WriteManager.new
+      access.rigor = access_manager.rigor
+      access.source_graph = graph
+      focus = GraphFocus.new(access, subject)
+
       graphs[subject] = graph
+
       yield focus if block_given?
       return focus
     end
-
-    def send_graphs
-      @graphs.each_pair do |url, graph|
-        graph_transfer.post(url, graph)
-      end
-    end
   end
 end

data/lib/roadforest/remote-host.rb

@@ -1,8 +1,8 @@
 require 'roadforest/rdf/source-rigor'
 require 'roadforest/rdf/source-rigor/credence-annealer'
+require 'roadforest/rdf/graph-store'
 require 'roadforest/http/graph-transfer'
 require 'roadforest/http/adapters/excon'
-require 'roadforest/rdf/graph-store'
 
 module RoadForest
   class RemoteHost
@@ -54,17 +54,19 @@ module RoadForest
     end
 
     def putting(&block)
-      require 'roadforest/rdf/update-focus'
       graph = build_graph_store
-      updater = RDF::UpdateFocus.new(url, graph, source_rigor)
+      access = RDF::UpdateManager.new
+      access.rigor = source_rigor
+      access.source_graph = graph
+      updater = RDF::GraphFocus.new(access, url)
       annealer = RDF::SourceRigor::CredenceAnnealer.new(graph)
 
       annealer.resolve do
-        updater.target_graph = ::RDF::Repository.new
+        access.target_graph = ::RDF::Repository.new
         yield updater
       end
 
-      target_graph = updater.target_graph
+      target_graph = access.target_graph
       target_graph.each_context do |context|
         graph = ::RDF::Graph.new(context, :data => target_graph)
         graph_transfer.put(context, graph)
@@ -74,16 +76,26 @@ module RoadForest
     def posting(&block)
       require 'roadforest/rdf/post-focus'
       graph = build_graph_store
-      poster = RDF::PostFocus.new(url, graph, source_rigor)
+      access = RDF::PostManager.new
+      access.rigor = source_rigor
+      access.source_graph = graph
+      poster = RDF::PostFocus.new(access, url)
+      graphs = {}
+      poster.graphs = graphs
 
       anneal(poster, &block)
 
-      poster.send_graphs
+      graphs.each_pair do |url, graph|
+        graph_transfer.post(url, graph)
+      end
     end
 
     def getting(&block)
       graph = build_graph_store
-      reader = RDF::GraphReading.new(url, graph, source_rigor)
+      access = RDF::ReadOnlyManager.new
+      access.rigor = source_rigor
+      access.source_graph = graph
+      reader = RDF::GraphFocus.new(access, url)
 
       anneal(reader, &block)
     end

data/lib/roadforest/resource/rdf/read-only.rb

@@ -1,13 +1,16 @@
-require 'roadforest/resource/handlers'
 require 'roadforest/application/parameters'
+require 'roadforest/utility/class-registry'
 
 module RoadForest
   module Resource
+    def self.registry_purpose; "resource type"; end
+    extend Utility::ClassRegistry::Registrar
+
     module RDF
       #Used for a resource that presents a read-only representation
       class ReadOnly < Webmachine::Resource
         def self.register(method_name)
-          Handlers.register(method_name, self)
+          RoadForest::Resource.registry.add(method_name, self)
         end
 
         register :read_only

data/lib/roadforest/test-support/matchers.rb

@@ -1,8 +1,15 @@
 module RoadForest
   module Testing
     class MatchesQuery
-      def initialize(&block)
-        @query = ::RDF::Query.new(&block)
+      def initialize(pattern = nil, &block)
+        pattern ||= []
+        if Hash === pattern
+          pattern = [pattern]
+        end
+        pattern = pattern.map do |item|
+          ::RDF::Query::Pattern.from(item)
+        end
+        @query = ::RDF::Query.new(pattern, &block)
       end
 
       def matches?(actual)
@@ -12,7 +19,11 @@ module RoadForest
       end
 
       def failure_message_for_should
-        "expected #{@query.inspect} to return solutions on #{@actual.inspect}, but didn't"
+        "expected #{@query.patterns.inspect} to return solutions on \n#{@actual.dump(:nquads)}\n but didn't"
+      end
+
+      def failure_message_for_should_not
+        "expected #{@query.patterns.inspect} not to return solutions on \n#{@actual.dump(:nquads)}\n but does"
       end
     end
 
@@ -21,15 +32,33 @@ module RoadForest
         @expected = expected
       end
 
+      def subtract(one, other)
+        sorted = one.sort_by{|stmt| stmt.to_a}
+        one.find_all do |expected_stmt|
+          not other.any? do |actual_stmt|
+            actual_stmt.eql? expected_stmt
+          end
+        end
+      end
+
+      def missing
+        @missing ||= subtract(@expected, @actual)
+      end
+
+      def surplus
+        @surplus ||= subtract(@actual, @expected)
+      end
+
       def matches?(actual)
         @actual = actual
-        @actual_extra = @actual - @expected
-        @expected_extra = @expected - @actual
-        @actual_extra.empty? and @expected_extra.empty?
+        missing.empty? and surplus.empty?
       end
 
       def failure_message_for_should
-        "expected #{@actual.inspect} to have the same elements as #{@expected.inspect}"
+        "expected [\n  #{@actual.map(&:to_s).join("\n  ")}\n] " +
+          "to have the same elements as [\n  #{@expected.map(&:to_s).join("\n  ")}\n]\n\n" +
+          "missing: [\n  #{missing.map(&:to_s).join("\n  ")}\n]\n" +
+          "surplus: [\n  #{surplus.map(&:to_s).join("\n  ")}]"
       end
     end
 
@@ -41,6 +70,8 @@ module RoadForest
       def that_match_query(query)
         @graph.query(query).to_a
       end
+      alias that_match that_match_query
+      alias that_match_pattern that_match_query
     end
 
     module HelperMethods
@@ -50,8 +81,8 @@ module RoadForest
     end
 
     module MatcherMethods
-      def match_query(&block)
-        MatchesQuery.new(&block)
+      def match_query(pattern = nil, &block)
+        MatchesQuery.new(pattern, &block)
       end
 
       def be_equivalent_to(list)

data/lib/roadforest/utility/class-registry.rb

@@ -1,6 +1,12 @@
 module RoadForest
   module Utility
     class ClassRegistry
+      #Extend a module with this in order to make it the registrar for a
+      #particular purpose.
+      #The top of a class heirarchy will make "register" immediately available
+      #to subclasses. Otherwise, classes can say Module::registry.add(name,
+      #self)
+      #
       module Registrar
         def registry
           @registry ||= ClassRegistry.new(self)
@@ -10,9 +16,10 @@ module RoadForest
           registrar.registry.add(name, self)
         end
 
-        def [](name)
+        def get(name)
           registrar.registry.get(name)
         end
+        alias [] get
 
         def self.extended(mod)
           (

data/spec/focus-list.rb

@@ -7,8 +7,14 @@ describe RoadForest::RDF::FocusList do
     RDF::Graph.new
   end
 
+  let :access do
+    RoadForest::RDF::WriteManager.new.tap do |access|
+      access.source_graph = graph
+    end
+  end
+
   let :focus do
-    RoadForest::RDF::GraphFocus.new("urn:root", graph)
+    RoadForest::RDF::GraphFocus.new(access, "urn:root")
   end
 
   let :list do

data/spec/graph-copier.rb

@@ -1,19 +1,7 @@
 require 'roadforest/test-support/matchers'
 require 'roadforest/rdf/graph-copier'
 
-#Leaving notes since being interrupted
-#
-#GC needs to tessellate the graph in the same way that Parceller should -
-#probably should make sure that works first. Basically same resource should ==
-#same subgraph copied, since otherwise client omission of a property isn't
-#distinguishable from the intent to delete it. Only copy once so that you don't
-#overwrite client changes.
-#
-#Also: "single put" involves a whole extra level of server code to accept the
-#put, parcel it out, confirm IMS headers across everyone... so that's a v2
-#feature
-
-describe RoadForest::RDF::GraphCopier, :pending => "review of API" do
+describe RoadForest::RDF::GraphFocus, "with a CopyManager" do
   class TestVoc < ::RDF::Vocabulary("http://test.com/");end
 
   let :start_subject do
@@ -27,12 +15,7 @@ describe RoadForest::RDF::GraphCopier, :pending => "review of API" do
   let :starting_statements do
     [
       [start_subject, TestVoc[:a], 7],
-      [start_subject, TestVoc[:other], other_subject]
-    ]
-  end
-
-  let :other_statements do
-    [
+      [start_subject, TestVoc[:other], other_subject],
       [other_subject, TestVoc[:a], 13]
     ]
   end
@@ -42,46 +25,47 @@ describe RoadForest::RDF::GraphCopier, :pending => "review of API" do
       starting_statements.each do |stmt|
         graph << stmt
       end
-
-      other_statements.each do |stmt|
-        graph << stmt
-      end
     end
   end
 
-  let :document do
-    RoadForest::RDF::Document.new.tap do |doc|
-      doc.source =
-      doc.body_string = source_graph.dump(:rdfa)
-    end
+  let :target_graph do
+    ::RDF::Graph.new
   end
 
-  let :copier do
-    RoadForest::RDF::GraphCopier.new.tap do |copier|
-      copier.source_graph = source_graph
-      copier.subject = start_subject
+  let :access do
+    RoadForest::RDF::CopyManager.new.tap do |access|
+      access.source_graph = source_graph
+      access.target_graph = target_graph
     end
   end
 
-  it "reads the notes above, unless it wants the hose again" do
-    fail "shoulda read the notes"
+  let :copier do
+    RoadForest::RDF::GraphFocus.new(access, start_subject)
   end
 
-  it "should have a target graph" do
-    copier.target_graph.should be_an_instance_of(::RDF::Graph)
-  end
+  #copier needs URL accessor
+
 
-  it "should have statements about starting subject" do
-    statements_from_graph(copier.target_graph).that_match_query(:subject => start_subject).should be_equivalent_to(starting_statements)
+
+  it "should not copy statements without action" do
+    target_graph.should_not match_query(:subject => start_subject)
   end
 
-  it "should not have statements about other subject" do
-    copier.target_graph.query(:subject => other_subject).to_a.should be_empty
+  it "should copy statements that are queried" do
+    copier[[:testvoc, :other]]
+
+    statements_from_graph(target_graph).that_match_query(:predicate => TestVoc[:other]).should(
+      be_equivalent_to(statements_from_graph(source_graph).that_match_query(:predicate => TestVoc[:other]))
+    )
+    target_graph.should_not match_query(:predicate => TestVoc[:a])
   end
 
-  it "should get statements about other subject" do
+  it "should not double copy statements that are queried twice" do
+    copier[[:testvoc, :other]]
     copier[[:testvoc, :other]]
 
-    statements_from_graph(copier.target_graph).that_match_query(:subject => other_subject).should be_equivalent_to(other_statements)
+    statements_from_graph(target_graph).that_match_query(:predicate => TestVoc[:other]).should(
+      be_equivalent_to(statements_from_graph(source_graph).that_match_query(:predicate => TestVoc[:other]))
+    )
   end
 end

data/spec/graph-store.rb

@@ -1,7 +1,9 @@
 require 'rdf'
-#require 'rdf/rdfa'
+require 'rdf/rdfa'
 require 'roadforest/rdf/document'
 require 'roadforest/rdf/graph-store'
+require 'roadforest/rdf/graph-focus'
+require 'roadforest/rdf/source-rigor'
 
 describe RoadForest::RDF do
   let :source_rigor do
@@ -20,7 +22,11 @@ describe RoadForest::RDF do
   describe RoadForest::RDF::GraphStore do
     let :root_body do
       store = RoadForest::RDF::GraphStore.new
-      step = RoadForest::RDF::GraphFocus.new("http://lrdesign.com/test-rdf", store, source_rigor)
+      access = RoadForest::RDF::WriteManager.new
+      access.source_graph = store
+      access.rigor = source_rigor
+      step = RoadForest::RDF::GraphFocus.new(access, "http://lrdesign.com/test-rdf")
+
       step[[:foaf, :givenname]] = "Lester"
       step[[:dc, :date]] = Time.now
       step = step.node_at([:dc, :related], "http://lrdesign.com/test-rdf/sub")
@@ -31,7 +37,11 @@ describe RoadForest::RDF do
 
     let :second_body do
       store = RoadForest::RDF::GraphStore.new
-      step = RoadForest::RDF::GraphFocus.new("http://lrdesign.com/test-rdf", store, source_rigor)
+      access = RoadForest::RDF::WriteManager.new
+      access.source_graph = store
+      access.rigor = source_rigor
+      step = RoadForest::RDF::GraphFocus.new(access, "http://lrdesign.com/test-rdf")
+
       step[[:foaf, :givenname]] = "Foster"
       step[[:dc, :date]] = Time.now
 
@@ -52,12 +62,18 @@ describe RoadForest::RDF do
       end
     end
 
+    let :step do
+      access = RoadForest::RDF::WriteManager.new
+      access.source_graph = graph_store
+      access.rigor = source_rigor
+      RoadForest::RDF::GraphFocus.new(access, "http://lrdesign.com/test-rdf")
+    end
+
     before :each do
       graph_store.insert_document(first_doc)
     end
 
     it "should transmit properties" do
-      step = RoadForest::RDF::GraphFocus.new("http://lrdesign.com/test-rdf", graph_store, source_rigor)
       step[:dc, :date].should be_an_instance_of(Time)
     end
 
@@ -65,7 +81,7 @@ describe RoadForest::RDF do
       expect{
         graph_store.insert_document(second_doc)
       }.to change{
-        RoadForest::RDF::GraphFocus.new("http://lrdesign.com/test-rdf", graph_store, source_rigor)[:foaf, :givenname]
+        step[:foaf, :givenname]
       }
     end
   end
@@ -83,16 +99,27 @@ describe RoadForest::RDF do
       RDF::Node.new
     end
 
+    let :graph_store do
+      RDF::Graph.new
+    end
+
     before :each do
-      graph_store.add_statement(root, [:dc, :relation], main_subject)
-      graph_store.add_statement(creator, [:foaf, :familyName], "Lester")
-      graph_store.add_statement(creator, [:foaf, :givenname], "Judson")
-      graph_store.add_statement(main_subject, [:dc, :creator], creator)
-      graph_store.add_statement(main_subject, [:dc, :date], Time.now)
+      graph_store.insert([root, ::RDF::DC.relation, main_subject])
+      graph_store.insert([creator, ::RDF::FOAF.familyName, "Lester"])
+      graph_store.insert([creator, ::RDF::FOAF.givenname, "Judson"])
+      graph_store.insert([main_subject, ::RDF::DC.creator, creator])
+      graph_store.insert([main_subject, ::RDF::DC.date, Time.now])
+    end
+
+    let :access do
+      RoadForest::RDF::WriteManager.new.tap do |access|
+        access.rigor = source_rigor
+        access.source_graph = graph_store
+      end
     end
 
     let :step do
-      RoadForest::RDF::GraphFocus.new(main_subject, graph_store, source_rigor)
+      RoadForest::RDF::GraphFocus.new(access, main_subject)
     end
 
     it "should enumerate forward properties" do
@@ -122,7 +149,7 @@ describe RoadForest::RDF do
       step[:dc,:creator][:foaf,:givenname].should == "Judson"
     end
 
-    it "should be able to add properties with []=", :pending => "Should GraphStores accept local writes?" do
+    it "should be able to add properties with []=" do
       step[[:dc, :dateCopyrighted]] = Time.now #slightly ugly syntax
       step[:dc, :dateCopyrighted].should be_an_instance_of(Time)
       RDF::Query.new do |query|
@@ -130,13 +157,12 @@ describe RoadForest::RDF do
       end.execute(graph_store).should_not be_empty
     end
 
-    it "should be able to add properties with set", :pending => "Should GraphStores accept local writes?" do
+    it "should be able to add properties with set" do
       step.set(:dc, :dateCopyrighted, Time.now)
       step[:dc, :dateCopyrighted].should be_an_instance_of(Time)
       RDF::Query.new do |query|
         query.pattern [:subject, RDF::DC.dateCopyrighted, :value]
-        store.execute(graph_store).should_not be_empty
-      end
+      end.execute(graph_store).should_not be_empty
     end
   end
 end