roadforest 0.1 → 0.5

data/lib/roadforest/{rdf → source-rigor}/graph-store.rb

@@ -1,14 +1,14 @@
 require 'rdf'
 require 'roadforest/debug'
-require 'roadforest/rdf/vocabulary'
-require 'roadforest/rdf/normalization'
+require 'roadforest/graph/vocabulary'
+require 'roadforest/graph/normalization'
 
-require 'roadforest/rdf/resource-query'
-require 'roadforest/rdf/resource-pattern'
+require 'roadforest/source-rigor/resource-query'
+require 'roadforest/source-rigor/resource-pattern'
 
-module RoadForest::RDF
-  class GraphStore
-    include Normalization
+module RoadForest
+  class SourceRigor::GraphStore
+    include Graph::Normalization
 
     #The interface supported by ::RDF::Graph
     include ::RDF::Countable
@@ -183,7 +183,7 @@ module RoadForest::RDF
     def query_execute(query, &block)
       #XXX Weird edge case of GM getting queried with a vanilla RDF::Query...
       #needs tests, thought
-      query = ResourceQuery.from(query)
+      query = RoadForest::SourceRigor::ResourceQuery.from(query)
       query.execute(self).filter do |solution|
         solution.respond_to?(:context) and not solution.context.nil?
       end.each(&block)
@@ -191,7 +191,7 @@ module RoadForest::RDF
 
     def query_pattern(pattern, &block)
       case pattern
-      when ResourcePattern
+      when RoadForest::SourceRigor::ResourcePattern
         pattern.execute(@repository, {}, :context_roles => {:local => local_context_node}) do |statement|
           next if statement.context.nil?
           yield statement if block_given?

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

@@ -1,6 +1,6 @@
-require 'roadforest/rdf/source-rigor/investigator'
+require 'roadforest/source-rigor/investigator'
 module RoadForest
-  class RDF::SourceRigor
+  module SourceRigor
     class HTTPInvestigator < Investigator
       register :http
 

data/lib/roadforest/{rdf → source-rigor}/investigation.rb

@@ -1,6 +1,6 @@
-require 'roadforest/rdf'
+require 'roadforest/graph'
 
-module RoadForest::RDF
+module RoadForest::SourceRigor
   class Investigation
     attr_accessor :context_roles, :queryable, :results, :source_rigor
 

data/lib/roadforest/{rdf/source-rigor → source-rigor}/investigator.rb

@@ -1,6 +1,6 @@
 require 'roadforest/utility/class-registry'
 
-class RoadForest::RDF::SourceRigor
+module RoadForest::SourceRigor
   class NotCredible < StandardError; end
   class NoCredibleResults < StandardError; end
 
@@ -13,5 +13,5 @@ class RoadForest::RDF::SourceRigor
     end
   end
 end
-require 'roadforest/rdf/source-rigor/null-investigator'
-require 'roadforest/rdf/source-rigor/http-investigator'
+require 'roadforest/source-rigor/null-investigator'
+require 'roadforest/source-rigor/http-investigator'

data/lib/roadforest/{rdf/source-rigor → source-rigor}/null-investigator.rb

@@ -1,5 +1,6 @@
-require 'roadforest/rdf/source-rigor/investigator'
-class RoadForest::RDF::SourceRigor
+require 'roadforest/source-rigor/investigator'
+
+module RoadForest::SourceRigor
   class NullInvestigator < Investigator
     register :null
 

data/lib/roadforest/{rdf → source-rigor}/parcel.rb

@@ -1,9 +1,9 @@
-require 'roadforest/rdf'
-require 'roadforest/rdf/normalization'
+require 'roadforest/graph'
+require 'roadforest/graph/normalization'
 
-module RoadForest::RDF
-  class Parcel
-    include Normalization
+module RoadForest
+  class SourceRigor::Parcel
+    include Graph::Normalization
 
     attr_accessor :graph
 

data/lib/roadforest/{rdf → source-rigor}/resource-pattern.rb

@@ -1,9 +1,9 @@
 require 'rdf/query/pattern'
-require 'roadforest/rdf'
-require 'roadforest/rdf/graph-store'
-require 'roadforest/rdf/investigation'
+require 'roadforest/graph'
+require 'roadforest/source-rigor/graph-store'
+require 'roadforest/source-rigor/investigation'
 
-module RoadForest::RDF
+module RoadForest::SourceRigor
   class ResourcePattern < ::RDF::Query::Pattern
     def self.from(pattern, options)
       pattern = case pattern
@@ -19,7 +19,7 @@ module RoadForest::RDF
                   options ||= {}
                   self.new(options.merge(pattern))
                 else
-                  raise ArgumentError, "expected RoadForest::RDF::ResourcePattern, RDF::Query::Pattern, RDF::Statement, Hash, or Array, but got #{pattern.inspect}"
+                  raise ArgumentError, "expected RoadForest::SourceRigor::ResourcePattern, RDF::Query::Pattern, RDF::Statement, Hash, or Array, but got #{pattern.inspect}"
                 end
 
       unless options.nil?
@@ -35,7 +35,7 @@ module RoadForest::RDF
     attr_accessor :context_roles, :source_rigor
 
     def execute(queryable, bindings = nil, query_context_roles = nil, &block)
-      unless queryable.is_a? RoadForest::RDF::GraphStore
+      unless queryable.is_a? RoadForest::SourceRigor::GraphStore
         return super(queryable, bindings || {}, &block)
       end
 

data/lib/roadforest/{rdf → source-rigor}/resource-query.rb

@@ -1,7 +1,7 @@
-require 'roadforest/rdf'
+require 'roadforest/graph'
 require 'rdf/query'
 
-module RoadForest::RDF
+module RoadForest::SourceRigor
   class ResourceQuery < ::RDF::Query
     def initialize(patterns = [], options = {}, &block)
       @subject_context = options[:subject_context]

data/lib/roadforest/source-rigor/rigorous-access.rb

@@ -0,0 +1,101 @@
+require 'roadforest/graph/access-manager'
+require 'roadforest/source-rigor/resource-query'
+require 'roadforest/source-rigor/resource-pattern'
+require 'roadforest/source-rigor/parcel'
+
+module RoadForest
+  module SourceRigor
+    module Rigorous
+      attr_accessor :rigor
+
+      def dup
+        other = self.class.allocate
+        other.resource = self.resource
+        other.rigor = self.rigor
+        other.source_graph = self.source_graph
+
+        return other
+      end
+
+      def build_query
+        ResourceQuery.new([], {}) do |query|
+          query.subject_context = resource
+          query.source_rigor = rigor
+          yield query
+        end
+      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
+    end
+
+    class RetrieveManager < Graph::ReadOnlyManager
+      include Rigorous
+    end
+
+    class PostManager < Graph::WriteManager
+      include Rigorous
+    end
+
+    class UpdateManager < Graph::SplitManager
+      include Rigorous
+
+      def initialize
+        @copied_contexts = {}
+      end
+
+      attr_accessor :copied_contexts
+
+      def dup
+        other = super
+        other.copied_contexts = self.copied_contexts
+        other.target_graph = self.target_graph
+        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
+  end
+end

data/lib/roadforest/templates/affordance-doc.haml

@@ -0,0 +1,23 @@
+!!! XML
+!!! 5
+%html{:xmlns => "http://www.w3.org/1999/xhtml", :lang => lang, :prefix => prefix}
+  - if base || title
+    %head
+      - if base
+        %base{:href => base}
+      - if title
+        %title= title
+  %body
+    - subjects.each do |subject|
+      - if subject.respond_to? :affordance?
+        %form{subject.attrs}
+          %input{type: "hidden", name: "rdf"}
+          - prefixes.each do |name, target|
+            - unless name.nil? or name.empty?
+              %input{type: "hidden", name: "n", value: name}
+            %input{type: "hidden", name: "v", value: target}
+
+          != yield(subject)
+      - else
+        %div{subject.attrs}
+          != yield(subject)

data/lib/roadforest/templates/affordance-property-values.haml

@@ -0,0 +1,13 @@
+%div.property
+  = rdfpost_curie("p", predicate)
+  - objects.each do |object|
+    - if object.is_subject?
+      = rdfpost_curie("o", object.subject)
+    - elsif object.attrs.empty?
+      = yield(object)
+    - else
+      %label{object.label_attrs}
+        %span= get_predicate_name(predicate)
+        %input{object.input_attrs(yield(object))}
+      - if(object.type_uri)
+        %input{type: "hidden", name: "lt", value: object.type_uri}

data/lib/roadforest/templates/affordance-subject.haml

@@ -0,0 +1,9 @@
+- if typeof
+  %span.type!= typeof
+
+= rdfpost_curie("s", subject)
+
+- predicates.each do |predicate|
+  != yield(predicate)
+- predicate_nodes.each do |subject|
+  %div{subject.attrs}= yield subject

data/lib/roadforest/templates/affordance-uri-object.haml

@@ -0,0 +1,2 @@
+= rdfpost_curie("o", object)
+%a{:property => get_curie(predicate), :href => object.to_s, :inlist => inlist}= object.to_s

data/lib/roadforest/templates/rdfpost-curie.haml

@@ -0,0 +1,6 @@
+- if reduced?
+  - unless prefix.empty?
+    %input{type: "hidden", name: "#{kind}n", value: prefix}
+  %input{type: "hidden", name: "#{kind}v", value: suffix}
+- else
+  %input{type: "hidden", name: "#{kind}u", value: uri}

data/lib/roadforest/test-support/dispatcher-facade.rb

@@ -3,6 +3,8 @@ require 'webmachine/headers'
 require 'webmachine/request'
 require 'webmachine/response'
 require 'webmachine/decision/flow'
+require 'webmachine/decision/fsm'
+
 module RoadForest
   module TestSupport
     class DispatcherFacade < BasicObject

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

@@ -1,7 +1,165 @@
+require 'rdf/isomorphic'
+require 'rspec/matchers'
+require 'nokogiri'
+
+class RDF::Repository
+  include RDF::Isomorphic
+end
+
 module RoadForest
   module Testing
+    module HelperMethods
+      def statements_from_graph(graph)
+        StatementsFromGraph.new(graph)
+      end
+
+      def normalize(graph)
+        case graph
+        when RDF::Queryable then graph
+        when IO, StringIO
+          RDF::Graph.new.load(graph, :base_uri => @info.about)
+        else
+          # Figure out which parser to use
+          g = RDF::Graph.new
+          reader_class = detect_format(graph)
+          reader_class.new(graph, :base_uri => @info.about).each {|s| g << s}
+          g
+        end
+      end
+    end
+
+    class BeEquivalentGraph
+      include HelperMethods
+      Info = Struct.new(:about, :num, :trace, :compare, :inputDocument, :outputDocument, :expectedResults, :format, :title)
+
+      def initialize(expected, info)
+        @expected = normalize(expected)
+
+        @info =
+          if info.respond_to?(:about)
+            info
+          elsif info.is_a?(Hash)
+            identifier = expected.is_a?(RDF::Graph) ? expected.context : info[:about]
+            trace = info[:trace]
+            trace = trace.join("\n") if trace.is_a?(Array)
+            i = Info.new(identifier, "0000", trace, info[:compare])
+            i.format = info[:format]
+            i
+          else
+            Info.new(expected.is_a?(RDF::Graph) ? expected.context : info, "0000", info.to_s)
+          end
+
+        @info.format ||= :ttl
+      end
+      attr_reader :expected, :info
+
+      def matches?(actual)
+        @actual = normalize(actual)
+        @actual.isomorphic_with?(@expected)# rescue false
+      end
+
+      def dump_graph(graph)
+        graph.dump(@info.format, :standard_prefixes => true)
+      rescue
+        begin
+          graph.dump(:nquads, :standard_prefixes => true)
+        rescue
+          graph.inspect
+        end
+      end
+
+      def description
+        "be equivalent to an expected graph" #graphs tend to be too long to use
+      end
+
+      def failure_message_for_should(actual)
+        info = @info.respond_to?(:about) ? @info.about : @info.inspect
+        if @expected.is_a?(RDF::Graph) && @actual.size != @expected.size
+          "Graph entry count differs:\nexpected: #{@expected.size}\nactual:   #{@actual.size}"
+        elsif @expected.is_a?(Array) && @actual.size != @expected.length
+          "Graph entry count differs:\nexpected: #{@expected.length}\nactual:   #{@actual.size}"
+        else
+          "Graph differs"
+        end +
+          "\n#{info + "\n" unless info.to_s.empty?}" +
+          (@info.inputDocument ? "Input file: #{@info.inputDocument}\n" : "") +
+        (@info.outputDocument ? "Output file: #{@info.outputDocument}\n" : "") +
+        "\nExpected:\n#{dump_graph(@expected)}" +
+          "\nResults:\n#{dump_graph(@actual)}" +
+          (@info.trace ? "\nDebug:\n#{@info.trace}" : "")
+      end
+    end
+
+    class HaveXpath
+      def initialize(xpath, value, trace)
+        @xpath, @value, @trace = xpath, value, trace
+      end
+      attr_reader :xpath, :value, :trace
+
+      def matches?(actual)
+        @doc = Nokogiri::HTML.parse(actual)
+        @namespaces = @doc.namespaces.merge("xhtml" => "http://www.w3.org/1999/xhtml", "xml" => "http://www.w3.org/XML/1998/namespace")
+        found = @doc.root.at_xpath(xpath, @namespaces)
+        case value
+        when false
+          found.nil?
+        when true
+          !found.nil?
+        when Array
+          found.to_s.split(" ").include?(*value)
+        when Regexp
+          found.to_s =~ value
+        else
+          found.to_s == value
+        end
+      end
+
+      def failure_message_for_should(actual)
+        trace ||= debug
+        msg =
+          case value
+          when true
+            "expected that #{xpath.inspect} would be present\nwas:\n  #{found.inspect}\n"
+          when false
+            "expected that #{xpath.inspect} would be absent\nwas:\n  #{found.inspect}\n"
+          else
+            "expected that #{xpath.inspect} would be\n  #{value.inspect}\nwas:\n  #{found.inspect}\n"
+          end
+        msg += "in:\n" + actual.to_s
+        msg +=  "\nDebug:#{trace.join("\n")}" if trace
+        msg
+      end
+
+      def failure_message_for_should_not(actual)
+        trace ||= debug
+        msg = "expected that #{xpath.inspect} would not be #{value.inspect} in:\n" + actual.to_s
+        msg +=  "\nDebug:#{trace.join("\n")}" if trace
+        msg
+      end
+    end
+
+    class Produces
+      def initialize(expected, info)
+        @expected, @info = expected, info
+      end
+      attr_reader :expected, :info
+
+      def matches?(actual)
+        actual == expected
+      end
+
+      def failure_message_for_should(actual)
+        "Expected: #{expected.inspect}\n" +
+        "Actual  : #{actual.inspect}\n" +
+        "Processing results:\n#{info.join("\n")}"
+      end
+    end
+
     class MatchesQuery
       def initialize(pattern = nil, &block)
+        if pattern.nil? and block.nil?
+          raise "Matches query (e.g. should match_query) created with no patterns: probably used a do block..."
+        end
         pattern ||= []
         if Hash === pattern
           pattern = [pattern]
@@ -74,17 +232,23 @@ module RoadForest
       alias that_match_pattern that_match_query
     end
 
-    module HelperMethods
-      def statements_from_graph(graph)
-        StatementsFromGraph.new(graph)
+    module MatcherMethods
+      def produce(expected, info)
+        Produces.new(expected, info)
+      end
+
+      def have_xpath(xpath, value = true, trace = nil)
+        HaveXpath.new(xpath, value, trace || debug)
       end
-    end
 
-    module MatcherMethods
       def match_query(pattern = nil, &block)
         MatchesQuery.new(pattern, &block)
       end
 
+      def be_equivalent_graph(graph, info = nil)
+        BeEquivalentGraph.new(graph, info)
+      end
+
       def be_equivalent_to(list)
         ListEquivalence.new(list)
       end