roadforest 0.0.1

data/lib/roadforest/test-support/trace-formatter.rb

@@ -0,0 +1,140 @@
+module RoadForest
+  class TraceFormatter
+    DECISION_NAMES = {
+      :b13 => "Service available?",
+      :b12 => "Known method?",
+      :b11 => "URI too long?",
+      :b10 => "Method allowed?",
+      :b9 => "Content-MD5 present?",
+      :b9a => "Content-MD5 valid?",
+      :b9b => "Malformed?",
+      :b8 => "Authorized?",
+      :b7 => "Forbidden?",
+      :b6 => "Okay Content-* Headers?",
+      :b5 => "Known Content-Type?",
+      :b4 => "Req Entity Too Large?",
+      :b3 => "OPTIONS?",
+      :c3 => "Accept exists?",
+      :c4 => "Acceptable media type available?",
+      :d4 => "Accept-Language exists?",
+      :d5 => "Acceptable language available?",
+      :e5 => "Accept-Charset exists?",
+      :e6 => "Acceptable Charset available?",
+      :f6 => "Accept-Encoding exists? (also, set content-type header here, now that charset is chosen)",
+      :f7 => "Acceptable encoding available?",
+      :g7 => "Resource exists?",
+      :g8 => "If-Match exists?",
+      :g9 => "If-Match: * exists?",
+      :g11 => "ETag in If-Match",
+      :h7 => "If-Match exists?",
+      :h10 => "If-Unmodified-Since exists?",
+      :h12 => "Last-Modified > I-UM-S?",
+      :i4 => "Moved permanently? (apply PUT to different URI)",
+      :i7 => "PUT?",
+      :i12 => "If-none-match exists?",
+      :i13 => "If-none-match: * exists?",
+      :j18 => "GET or HEAD?",
+      :k5 => "Moved permanently?",
+      :k7 => "Previously existed?",
+      :k13 => "Etag in if-none-match?",
+      :l5 => "Moved temporarily?",
+      :l7 => "POST?",
+      :l13 => "If-Modified-Since exists?",
+      :l15 => "IMS > Now?",
+      :l17 => "Last-Modified > IMS?",
+      :m5 => "POST?",
+      :m7 => "Server allows POST to missing resource?",
+      :m16 => "DELETE?",
+      :m20 => "DELETE enacted immediately? (Also where DELETE is forced.)",
+      :m20b => "Did the DELETE complete?",
+      :n5 => "Server allows POST to missing resource?",
+      :n11 => "Redirect?",
+      :n16 => "POST?",
+      :o14 => "Conflict?",
+      :o16 => "PUT?",
+      :o18 => "Multiple representations? Also where body generation for GET and HEAD is done.",
+      :o18b => "Multiple choices?",
+      :o20 => "Response includes an entity?",
+      :p3 => "Conflict?",
+      :p11 => "New resource?",
+    }
+
+    def initialize(trace)
+      @trace = trace
+    end
+
+    def to_s
+      Grouper.new(@trace).to_a.join("\n")
+    end
+
+    class Grouper
+      include Enumerable
+
+      def initialize(trace)
+        @trace = trace
+      end
+
+      def format_attempt(attempt)
+        unless attempt.length == 2 and
+          attempt[0][:type] == :attempt and
+          attempt[1][:type] == :result
+          raise "Can't format attempt: #{attempt.inspect}"
+        end
+        name= attempt[0][:name]
+        source= attempt[0][:source]
+        result= attempt[1][:value]
+
+        if source.nil?
+          "  #{name} => #{result.inspect}"
+        else
+          "\n  #{name}\n  #{source}\n    => #{result.inspect}"
+        end
+      end
+
+      def format_request(request)
+        "\nRequest:\n  #{request[:method]} #{request[:path]}\n#{request[:headers].map do |name, value|
+          "  #{name}: #{value}"
+        end.join("\n")}#{request[:body].empty? ? "" : "\n\n  #{request[:body]}"}\n.\n"
+      end
+
+      def format_response(response)
+        "\nResponse:\n  #{response[:code]}\n#{response[:headers].map do |name, value|
+          "  #{name}: #{value}"
+        end.join("\n")}#{response[:body].empty? ? "" : "\n\n  #{response[:body]}"}\n.\n"
+      end
+
+      def format_decision(item)
+        "\nDecision: #{DECISION_NAMES[item[:decision]]} (#{item[:decision]})"
+      end
+
+      def each
+        enum = @trace.each
+
+        group = []
+        loop do
+          begin
+            item = enum.next
+            case item[:type]
+            when :request
+              yield format_request(item)
+            when :response
+              yield format_response(item)
+            when :attempt
+              group << item
+            when :result
+              group << item
+              yield format_attempt(group)
+              group = []
+            when :decision
+              yield format_decision(item)
+            else
+              raise "Don't know trace entry type: #{item.inspect}"
+            end
+          rescue StopIteration
+            break
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roadforest/test-support.rb

@@ -0,0 +1,2 @@
+require 'roadforest/test-support/remote-host'
+require 'roadforest/test-support/matchers'

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

@@ -0,0 +1,49 @@
+module RoadForest
+  module Utility
+    class ClassRegistry
+      module Registrar
+        def registry
+          @registry ||= ClassRegistry.new(self)
+        end
+
+        def register(name)
+          registrar.registry.add(name, self)
+        end
+
+        def [](name)
+          registrar.registry.get(name)
+        end
+
+        def self.extended(mod)
+          (
+            class << mod; self; end
+          ).instance_exec(mod) do |mod|
+            define_method :registrar do
+              mod
+            end
+          end
+        end
+      end
+
+      def initialize(registrar)
+        if registrar.respond_to?(:registry_purpose)
+          @purpose = registrar.registry_purpose
+        else
+          @purpose = registrar.name
+        end
+        @classes = {}
+      end
+
+      def add(name, klass)
+        @classes[name.to_sym] = klass
+        @classes[name.to_s] = klass
+      end
+
+      def get(name)
+        @classes.fetch(name)
+      rescue KeyError
+        raise "No #@purpose class registered as name: #{name.inspect}"
+      end
+    end
+  end
+end

data/lib/roadforest.rb

@@ -0,0 +1,2 @@
+module RoadForest
+end

data/spec/client.rb

@@ -0,0 +1,152 @@
+require 'roadforest/server'
+require 'roadforest/test-support'
+
+require 'examples/file-management'
+
+describe RoadForest::RemoteHost do
+  let :destination_dir do
+    "spec_support/destination"
+  end
+
+  let :source_path do
+    "spec_support/test-file.txt"
+  end
+
+  let :services do
+    FileManagementExample::ServicesHost.new.tap do |host|
+      host.file_records = [
+        FileManagementExample::FileRecord.new("one", false),
+        FileManagementExample::FileRecord.new("two", false),
+        FileManagementExample::FileRecord.new("three", false)
+      ]
+      host.destination_dir = destination_dir
+    end
+  end
+
+  let :server do
+    RoadForest::TestSupport::RemoteHost.new(FileManagementExample::Application.new("http://roadforest.test-domain.com/", services))
+  end
+
+  def dump_trace
+    tracing = true
+    tracing = false
+    if tracing
+      RoadForest::TestSupport::FSM.dump_trace
+    end
+  end
+
+  before :each do
+    RoadForest::TestSupport::FSM.trace_on
+  end
+
+  before :each do
+    require 'fileutils'
+    FileUtils.rm_f(destination_dir)
+    FileUtils.mkdir_p(destination_dir)
+  end
+
+  describe "raw put of file data" do
+    before :each do
+      @destination = nil
+      server.getting do |graph|
+        items = graph.all(:skos, "hasTopConcept")
+
+        unresolved = items.find do |nav_item|
+          nav_item[:skos, "label"] == "Unresolved"
+        end
+
+        target = unresolved.first(:foaf, "page")
+
+        @destination = target.first(:lc, "needs").as_list.first[:lc, "contents"]
+      end
+
+      unless @destination.nil?
+        File::open(source_path) do |file|
+          server.put_file(@destination, "text/plain", file)
+        end
+      end
+    end
+
+    it "should be able to format traces correctly" do
+      RoadForest::TestSupport::FSM.trace_dump.should =~ /Decision/
+    end
+
+    it "should set destination" do
+      @destination.to_context.to_s.should == "http://roadforest.test-domain.com/files/one"
+    end
+
+    it "should deliver file to destination path" do
+      File::read(File::join(destination_dir, "one")).should ==
+        File::read(source_path)
+    end
+  end
+
+  describe "posting data to server" do
+    before :each do
+      begin
+        server.posting do |graph|
+          items = graph.all(:skos, "hasTopConcept")
+
+          unresolved = items.find do |nav_item|
+            nav_item[:skos, "label"] == "Unresolved"
+          end
+
+          target = unresolved.first(:foaf, "page")
+
+          target.post_to do |new_need|
+            new_need[[:lc, "name"]] = "lawyers/guns/money"
+          end
+        end
+      ensure
+        dump_trace
+      end
+    end
+
+    it "should change the server state" do
+      services.file_records.find do |record|
+        record.name == "lawyers/guns/money"
+      end.should be_an_instance_of FileManagementExample::FileRecord
+    end
+  end
+
+  describe "putting data to server" do
+    before :each do
+      server.putting do |graph|
+        items = graph.all(:skos, "hasTopConcept")
+
+        unresolved = items.find do |nav_item|
+          nav_item[:skos, "label"] == "Unresolved"
+        end
+
+        target = unresolved.first(:foaf, "page")
+
+        needs = target.first(:lc, "needs").as_list
+
+        needs.each do |need|
+          need[[:lc, "resolved"]] = true
+        end
+      end
+    end
+
+    it "should change the server state" do
+      services.file_records.each do |record|
+        record.resolved.should == true
+      end
+    end
+
+    it "should extract data from server responses" do
+      server.should match_query do
+        pattern(:subject, [:lc, "path"], nil)
+        pattern(:subject, [:lc, "file"], nil)
+      end
+    end
+
+    it "should return correct content-type" do
+      #test_server.http_exchanges.each{|ex| puts ex.response.body}
+      server.http_exchanges.should_not be_empty
+      server.http_exchanges.each do |exchange|
+        exchange.response.headers["Content-Type"].should == "application/ld+json"
+      end
+    end
+  end
+end

data/spec/credence-annealer.rb

@@ -0,0 +1,44 @@
+require 'roadforest/rdf/source-rigor/credence-annealer'
+require 'roadforest/rdf/graph-store'
+require 'timeout'
+
+describe RoadForest::RDF::SourceRigor::CredenceAnnealer do
+  let :graph do
+    RoadForest::RDF::GraphStore.new
+  end
+
+  subject :annealer do
+    RoadForest::RDF::SourceRigor::CredenceAnnealer.new(graph)
+  end
+
+  it "should run it's block at least once" do
+    tested = false
+    annealer.resolve do
+      tested = true
+    end
+    tested.should be_true
+  end
+
+  it "should re-run it's block until the GraphStore settles" do
+    graph.stub(:quiet_impulse?).and_return(false, false, true)
+
+    times_run = 0
+    annealer.resolve do
+      times_run += 1
+    end
+
+    times_run.should == 3
+  end
+
+  it "should produce an error in some infinite-loop style situation" do
+    graph.stub(:quiet_impulse?).and_return(false)
+
+    expect do
+      Timeout::timeout(1) do
+        annealer.resolve do
+        end
+      end
+    end.to raise_error(/Annealing failed/)
+  end
+
+end

data/spec/graph-copier.rb

@@ -0,0 +1,87 @@
+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
+  class TestVoc < ::RDF::Vocabulary("http://test.com/");end
+
+  let :start_subject do
+    RDF::Node.new
+  end
+
+  let :other_subject do
+    RDF::Node.new
+  end
+
+  let :starting_statements do
+    [
+      [start_subject, TestVoc[:a], 7],
+      [start_subject, TestVoc[:other], other_subject]
+    ]
+  end
+
+  let :other_statements do
+    [
+      [other_subject, TestVoc[:a], 13]
+    ]
+  end
+
+  let :source_graph do
+    ::RDF::Graph.new.tap do |graph|
+      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
+  end
+
+  let :copier do
+    RoadForest::RDF::GraphCopier.new.tap do |copier|
+      copier.source_graph = source_graph
+      copier.subject = start_subject
+    end
+  end
+
+  it "reads the notes above, unless it wants the hose again" do
+    fail "shoulda read the notes"
+  end
+
+  it "should have a target graph" do
+    copier.target_graph.should be_an_instance_of(::RDF::Graph)
+  end
+
+  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)
+  end
+
+  it "should not have statements about other subject" do
+    copier.target_graph.query(:subject => other_subject).to_a.should be_empty
+  end
+
+  it "should get statements about other subject" do
+    copier[[:testvoc, :other]]
+
+    statements_from_graph(copier.target_graph).that_match_query(:subject => other_subject).should be_equivalent_to(other_statements)
+  end
+end

data/spec/graph-store.rb

@@ -0,0 +1,142 @@
+require 'rdf'
+#require 'rdf/rdfa'
+require 'roadforest/rdf/document'
+require 'roadforest/rdf/graph-store'
+
+describe RoadForest::RDF do
+  let :source_rigor do
+    RoadForest::RDF::SourceRigor.new.tap do |skept|
+      skept.policy_list(:may_subject)
+      skept.investigator_list(:null)
+    end
+  end
+
+  let :graph_store do
+    RoadForest::RDF::GraphStore.new
+  end
+
+  #merging graphs
+
+  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)
+      step[[:foaf, :givenname]] = "Lester"
+      step[[:dc, :date]] = Time.now
+      step = step.node_at([:dc, :related], "http://lrdesign.com/test-rdf/sub")
+      step[[:dc, :date]] = Time.now
+
+      store.graph_dump(:rdfa)
+    end
+
+    let :second_body do
+      store = RoadForest::RDF::GraphStore.new
+      step = RoadForest::RDF::GraphFocus.new("http://lrdesign.com/test-rdf", store, source_rigor)
+      step[[:foaf, :givenname]] = "Foster"
+      step[[:dc, :date]] = Time.now
+
+      store.graph_dump(:rdfa)
+    end
+
+    let :first_doc do
+      RoadForest::RDF::Document.new.tap do |doc|
+        doc.source = "http://lrdesign.com/test-rdf"
+        doc.body_string = root_body
+      end
+    end
+
+    let :second_doc do
+      RoadForest::RDF::Document.new.tap do |doc|
+        doc.source = "http://lrdesign.com/test-rdf"
+        doc.body_string = second_body
+      end
+    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
+
+    it "should replace previous statements from same URL" 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]
+      }
+    end
+  end
+
+  describe RoadForest::RDF::GraphFocus do
+    let :main_subject do
+      RDF::URI.new("http://test.com/main")
+    end
+
+    let :creator do
+      RDF::Node.new
+    end
+
+    let :root do
+      RDF::Node.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)
+    end
+
+    let :step do
+      RoadForest::RDF::GraphFocus.new(main_subject, graph_store, source_rigor)
+    end
+
+    it "should enumerate forward properties" do
+      step.forward_properties.should include([:dc, :creator])
+      step.forward_properties.should include([:dc, :date])
+      step.forward_properties.should_not include([:foaf, :familyName])
+      step.forward_properties.should_not include([:dc, :relation])
+    end
+
+    it "should get values for properties" do
+      step.get(:dc, :creator).rdf.should == creator
+      step.get(:dc, :date).should be_an_instance_of(Time)
+      step[:dc, :date].should be_an_instance_of(Time)
+      step[[:dc, :date]].should be_an_instance_of(Time)
+    end
+
+    it "should enumerate reverse properties" do
+      step.reverse_properties.should include([:dc, :relation])
+      step.reverse_properties.should_not include([:dc, :creator])
+    end
+
+    it "should get values for inbound properties" do
+      step.rev(:dc, :relation).rdf.should == root
+    end
+
+    it "should walk forward to properties" do
+      step[:dc,:creator][:foaf,:givenname].should == "Judson"
+    end
+
+    it "should be able to add properties with []=", :pending => "Should GraphStores accept local writes?" do
+      step[[:dc, :dateCopyrighted]] = Time.now #slightly ugly syntax
+      step[:dc, :dateCopyrighted].should be_an_instance_of(Time)
+      RDF::Query.new do |query|
+        query.pattern [:subject, RDF::DC.dateCopyrighted, :value]
+      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
+      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
+  end
+end

data/spec/media-types.rb

@@ -0,0 +1,14 @@
+require 'roadforest/content-handling/media-type'
+describe RoadForest::ContentHandling::MediaType do
+  let :accepted_list do
+    RoadForest::ContentHandling::MediaTypeList.build("text/*;q=0.3, text/html;q=0.7, text/html;level=1, text/html;level=2;q=0.4, */*;q=0.5")
+  end
+
+  let :provided_list do
+    RoadForest::ContentHandling::MediaTypeList.build("text/html;q=0.9;rdfa=true, application/json+ld;q=0.4")
+  end
+
+  it "should find best match" do
+    accepted_list.best_match_from(provided_list).should =~ "text/html"
+  end
+end