roadforest 0.5 → 0.7

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

@@ -3,6 +3,9 @@
   - objects.each do |object|
     - if object.is_subject?
       = rdfpost_curie("o", object.subject)
+      %label{}
+        %span= get_predicate_name(predicate)
+        %input{object.attrs.merge(:readonly => true)}
     - elsif object.attrs.empty?
       = yield(object)
     - else

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

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

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

@@ -6,6 +6,10 @@ class RDF::Repository
   include RDF::Isomorphic
 end
 
+class RDF::Graph
+  include RDF::Isomorphic
+end
+
 module RoadForest
   module Testing
     module HelperMethods
@@ -13,6 +17,23 @@ module RoadForest
         StatementsFromGraph.new(graph)
       end
 
+      # Heuristically detect the input stream
+      def detect_format(stream)
+        # Got to look into the file to see
+        if stream.is_a?(IO) || stream.is_a?(StringIO)
+          stream.rewind
+          string = stream.read(1000)
+          stream.rewind
+        else
+          string = stream.to_s
+        end
+        case string
+        when /<html/i   then RDF::RDFa::Reader
+        when /@prefix/i then RDF::Turtle::Reader
+        else                 RDF::NTriples::Reader
+        end
+      end
+
       def normalize(graph)
         case graph
         when RDF::Queryable then graph
@@ -22,7 +43,7 @@ module RoadForest
           # 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}
+          reader_class.new(graph, :base_uri => @info.nil? ? nil : @info.about).each {|s| g << s}
           g
         end
       end
@@ -72,7 +93,7 @@ module RoadForest
         "be equivalent to an expected graph" #graphs tend to be too long to use
       end
 
-      def failure_message_for_should(actual)
+      def failure_message_for_should
         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}"
@@ -94,12 +115,18 @@ module RoadForest
       def initialize(xpath, value, trace)
         @xpath, @value, @trace = xpath, value, trace
       end
-      attr_reader :xpath, :value, :trace
+      attr_reader :xpath, :value, :trace, :actual
+      attr_accessor :found
+
+      def description
+        "should match #{@xpath.inspect}"
+      end
 
       def matches?(actual)
+        @actual = 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)
+        self.found = @doc.root.at_xpath(xpath, @namespaces)
         case value
         when false
           found.nil?
@@ -114,8 +141,7 @@ module RoadForest
         end
       end
 
-      def failure_message_for_should(actual)
-        trace ||= debug
+      def failure_message_for_should
         msg =
           case value
           when true
@@ -130,8 +156,7 @@ module RoadForest
         msg
       end
 
-      def failure_message_for_should_not(actual)
-        trace ||= debug
+      def failure_message_for_should_not
         msg = "expected that #{xpath.inspect} would not be #{value.inspect} in:\n" + actual.to_s
         msg +=  "\nDebug:#{trace.join("\n")}" if trace
         msg
@@ -176,13 +201,18 @@ module RoadForest
         not solutions.empty?
       end
 
+      def indent(string)
+        string.split("\n").map{|line| "  " + line}.join("\n")
+      end
+
       def failure_message_for_should
-        "expected #{@query.patterns.inspect} to return solutions on \n#{@actual.dump(:nquads)}\n but didn't"
+        require 'pp'
+        "expected: \n#{indent(@query.patterns.pretty_inspect)} \nto return solutions on \n\n#{indent(@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
+        require 'pp'
+        "expected: \n#{indent(@query.patterns.pretty_inspect)} \nnot to return solutions on \n\n#{indent(@actual.dump(:nquads))}\n but does" end
     end
 
     class ListEquivalence
@@ -191,7 +221,6 @@ module RoadForest
       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

data/lib/roadforest/test-support/remote-host.rb

@@ -3,9 +3,9 @@ require 'roadforest/remote-host'
 require 'roadforest/test-support/http-client'
 module RoadForest::TestSupport
   class RemoteHost < ::RoadForest::RemoteHost
-    def initialize(app)
-      @app = app
-      super(app.canonical_host)
+    def initialize(services)
+      @app = RoadForest::Application.new(services)
+      super(services.canonical_host)
     end
 
     def build_graph_store

data/lib/roadforest/type-handlers/rdfa-writer/environment-decorator.rb

@@ -264,7 +264,7 @@ module RoadForest
 
         def attrs
           _decorated_.attrs.merge(
-            :method => "POST", :action => subject.join("put")
+            :method => "POST", :action => subject / "put"
           )
         end
       end

data/lib/roadforest/type-handlers/rdfa-writer/render-engine.rb

@@ -29,7 +29,8 @@ module RoadForest::TypeHandlers
         end.handle_templates do |config|
           #At some point, should look into using HTML entities to preserve
           #whitespace in XMLLiterals
-          config.add_type("haml", { :template_cache => template_cache, :template_options => haml_options || {:ugly => true} })
+          options = {:format => :xhtml}.merge(haml_options || {:ugly => true})
+          config.add_type("haml", { :template_cache => template_cache, :template_options => options })
         end
       end
 
@@ -56,10 +57,12 @@ module RoadForest::TypeHandlers
       attr_accessor :prefixes, :base_uri, :lang, :standard_prefixes, :graph, :titles, :doc_title, :graph_name
       attr_accessor :template_handler
       attr_reader :debug
+      attr_accessor :debugging_comments
 
       attr_reader :decoration_set
 
       def initialize(graph, debug=nil)
+        @debugging_comments = false
         @debug = debug
         @graph = graph
         @graph_name = nil
@@ -104,11 +107,18 @@ module RoadForest::TypeHandlers
 
       def add_debug(message = nil)
         return unless ::RoadForest.debug_io || @debug
-        message ||= ""
-        message = message + yield if block_given?
-        msg = "#{'  ' * @debug_indent}#{message}"
-        RoadForest::debug(msg)
-        @debug << msg.force_encoding("utf-8") if @debug.is_a?(Array)
+        message ||= "  " * @debug_indent
+        begin
+          message = message + yield if block_given?
+        rescue => ex
+          message += ex.inspect
+          message += "\n"
+          message += ex.backtrace[0...10].map do |line|
+            ("  " * (@debug_indent + 1)) + line
+          end.join("\n")
+        end
+        RoadForest::debug(message)
+        @debug << message.force_encoding("utf-8") if @debug.is_a?(Array)
       end
 
       def setup
@@ -171,7 +181,6 @@ module RoadForest::TypeHandlers
           !seen.include?(s)
         end.each do |class_uri|
           graph.query(:predicate => RDF.type, :object => class_uri).map {|st| st.subject}.sort.uniq.each do |subject|
-            #add_debug {"order_subjects: #{subject.inspect}"}
             subjects << subject
             seen[subject] = true
           end
@@ -184,9 +193,9 @@ module RoadForest::TypeHandlers
           [r.is_a?(RDF::Node) ? 1 : 0, ref_count(r), r]
         end.sort
 
-        add_debug {"order_subjects: #{recursable.inspect}"}
-
         subjects += recursable.map{|r| r.last}
+        add_debug {"order_subjects: (final) \n  #{subjects.join("\n  ")}"}
+        return subjects
       end
 
       def order_properties(properties)
@@ -231,21 +240,21 @@ module RoadForest::TypeHandlers
         curie =
           case
           when @uri_to_term_or_curie.has_key?(uri)
-            add_debug {"get_curie(#{uri}): uri_to_term_or_curie #{@uri_to_term_or_curie[uri].inspect}"}
+            add_debug {"get_curie(#{uri}): cached: #{@uri_to_term_or_curie[uri].inspect}"}
             return @uri_to_term_or_curie[uri]
           when base_uri && uri.index(base_uri.to_s) == 0
-            add_debug {"get_curie(#{uri}): base_uri (#{uri.sub(base_uri.to_s, "")})"}
+            add_debug {"get_curie(#{uri}): base_uri: (#{base_uri} + #{uri.sub(base_uri.to_s, "")})"}
             uri.sub(base_uri.to_s, "")
           when @vocabulary && uri.index(@vocabulary) == 0
-            add_debug {"get_curie(#{uri}): vocabulary"}
+            add_debug {"get_curie(#{uri}): vocabulary: #{@vocabulary.inspect}"}
             uri.sub(@vocabulary, "")
           when u = @uri_to_prefix.keys.detect {|u| uri.index(u.to_s) == 0}
-            add_debug {"get_curie(#{uri}): uri_to_prefix"}
+            add_debug {"get_curie(#{uri}): uri_to_prefix: #{@uri_to_prefix[u]}"}
             prefix = @uri_to_prefix[u]
             @prefixes[prefix] = u
             uri.sub(u.to_s, "#{prefix}:")
           when @standard_prefixes && vocab = RDF::Vocabulary.detect {|v| uri.index(v.to_uri.to_s) == 0}
-            add_debug {"get_curie(#{uri}): standard_prefixes"}
+            add_debug {"get_curie(#{uri}): standard_prefixes: #{vocab}"}
             prefix = vocab.__name__.to_s.split('::').last.downcase
             @prefixes[prefix] = vocab.to_uri
             uri.sub(vocab.to_uri.to_s, "#{prefix}:")
@@ -288,8 +297,6 @@ module RoadForest::TypeHandlers
       end
 
       def render(context)
-        #puts "\n#{__FILE__.sub(/^#{Dir.pwd}/,'')}:#{__LINE__} =>
-        ##{context.class.inspect}"
         add_debug "render"
         if context.render_checked
           return ""
@@ -297,11 +304,17 @@ module RoadForest::TypeHandlers
         template = find_environment_template(context)
         depth do
           add_debug{ "template: #{template.file}" }
+          add_debug{ "options: #{template.options}" }
           add_debug{ "context: #{context.class.name}"}
+          add_debug{ "  #{context.attrs}" } if context.respond_to?(:attrs)
 
           begin
             @render_stack.push context
-            template.render(context) do |item|
+            prefix = ""
+            if debugging_comments
+              prefix = "<!-- #{template.file} -->"
+            end
+            prefix + template.render(context) do |item|
               context.yielded(item)
             end.sub(/\n\Z/,'')
           ensure
@@ -311,7 +324,7 @@ module RoadForest::TypeHandlers
       end
 
       def is_list?(object)
-        !(object == RDF.nil || (l = RDF::List.new(object, @graph)).invalid?)
+        !(object == RDF.nil || (RDF::List.new(object, @graph)).invalid?)
       end
 
       def subject_done(subject)
@@ -332,6 +345,15 @@ module RoadForest::TypeHandlers
         properties
       end
 
+      def build_env(klass)
+        env = klass.new(self)
+        env.heading_predicates = heading_predicates
+        env.lang = lang
+        env.parent = @render_stack.last
+        yield(env)
+        return decoration_set.decoration_for(env)
+      end
+
       def document_env
         build_env(DocumentEnvironment) do |env|
           env.subject_terms = @ordered_subjects
@@ -365,15 +387,6 @@ module RoadForest::TypeHandlers
         end
       end
 
-      def build_env(klass)
-        env = klass.new(self)
-        env.heading_predicates = heading_predicates
-        env.lang = lang
-        env.parent = @render_stack.last
-        yield(env)
-        return decoration_set.decoration_for(env)
-      end
-
       def object_env(predicate, object)
         subj = subject_env(object)
         unless subj.nil?

data/lib/roadforest/type-handlers/rdfa.rb

@@ -14,6 +14,7 @@ module RoadForest
       include Graph::Normalization
 
       attr_writer :valise, :tilt_cache
+      attr_accessor :haml_options
 
       def valise
         @valise ||= Valise.define do
@@ -33,9 +34,10 @@ module RoadForest
         templates = RDFaWriter::TemplateHandler.new
         templates.valise = valise
         templates.template_cache = tilt_cache
+        templates.haml_options = haml_options
 
         engine = RDFaWriter::RenderEngine.new(rdf, debug) do |engine|
-          engine.graph_name = rdf.context
+          #engine.graph_name = nil #was: rdf.context
           engine.base_uri = base_uri
           engine.standard_prefixes = true
           engine.template_handler = templates
@@ -53,10 +55,15 @@ module RoadForest
           prefixes[prefix.to_sym] = prefixes[prefix]
         end
         engine.prefixes.merge! prefixes
-
-        #$stderr.puts debug
+        engine.prefixes.keys.each do |key|
+          if key.is_a? String
+            engine.prefixes[key.to_sym] = engine.prefixes.delete(key)
+          end
+        end
 
         result = engine.render_document
+        #puts "\n#{__FILE__}:#{__LINE__} => \n#{debug.join("\n")}"
+        return result
       end
 
       def network_to_local(base_uri, source)

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

@@ -50,28 +50,68 @@ module RoadForest
         else
           @purpose = purpose
         end
+        @sequence = NameSequence.new
         @classes = {}
       end
 
+      require 'tsort'
+      class NameSequence
+        include TSort
+
+        def initialize
+          @nodes = Hash.new do |h,k|
+            h[k] = []
+          end
+        end
+
+        def add(before, after)
+          @nodes[before] << after
+        end
+
+        def exists(node)
+          @nodes[node] ||= []
+        end
+
+        def tsort_each_node(&block)
+          @nodes.each_key(&block)
+        end
+
+        def tsort_each_child(node, &block)
+          @nodes.fetch(node).each(&block)
+        end
+      end
+
+      # @yield each class in name order
       def map_classes
         names.map do |name|
-          yield get(name)
+          begin
+            yield get(name)
+          rescue UndefinedClass
+            warn "undefined name: #{name} used in sequencing"
+          end
         end
       end
 
+      def names
+        @sequence.tsort
+      end
+
       def add(name, klass)
+        @sequence.exists(name.to_sym)
         @classes[name.to_sym] = klass
         @classes[name.to_s] = klass
       end
 
-      def names
-        @classes.keys.select{|key| key.is_a? Symbol}
+      def seq(before, after)
+        @sequence.add(before.to_sym, after.to_sym)
       end
 
+      class UndefinedClass < StandardError; end
+
       def get(name)
         @classes.fetch(name)
       rescue KeyError
-        raise "No #@purpose class registered as name: #{name.inspect} (there are: #{names.inspect})"
+        raise UndefinedClass, "No #@purpose class registered as name: #{name.inspect} (there are: #{names.inspect})"
       end
     end
   end

data/spec/affordance-augmenter.rb

@@ -4,7 +4,24 @@ require 'roadforest/application'
 
 describe RoadForest::Augment::Affordance do
   let :test_interface do
-    Class.new(RoadForest::Interface::RDF)
+    Class.new(RoadForest::Interface::RDF) do |klass|
+      def update_payload
+        payload_pair do |root_node, graph|
+          seg1 = ::RDF::Node.new
+          graph << [ root_node, Path.forward, seg1 ]
+          graph << [ seg1, Path.predicate, EX.b ]
+        end
+      end
+
+      def create_payload
+        payload_pair do |root_node, graph|
+          seg1 = ::RDF::Node.new
+          graph << [ root_node, Path.forward, seg1 ]
+          graph << [ seg1, Path.predicate, EX.val ]
+          graph << [ seg1, Path.type, ::RDF::XSD.integer ]
+        end
+      end
+    end
   end
 
   let :other_test_interface do
@@ -12,11 +29,17 @@ describe RoadForest::Augment::Affordance do
   end
 
   Af = RoadForest::Graph::Af
+  Path = RoadForest::Graph::Path
 
   class EX < RDF::Vocabulary("http://example.com/"); end
 
   let :service_host do
-    RoadForest::Application::ServicesHost.new
+    RoadForest::Application::ServicesHost.new.tap do |services|
+      services.root_url = "http://example.com/a"
+
+      services.router.add :test, ["a"], :parent, test_interface
+      services.router.add :nest, ["a", "b", :id], :leaf, other_test_interface
+    end
   end
 
   let :content_engine do
@@ -24,24 +47,11 @@ describe RoadForest::Augment::Affordance do
   end
 
   let :application do
-    double("RoadForest::Application").tap do |app|
-      app.stub(:services).and_return(service_host)
-      app.stub(:default_content_engine).and_return(content_engine)
-    end
-  end
-
-  let :router do
-    RoadForest::Dispatcher.new(application).tap do |router|
-      router.add :test, ["a"], :parent, test_interface
-      router.add :nest, ["a", "b", :id], :leaf, other_test_interface
-    end
+    RoadForest::Application.new(service_host)
   end
 
   let :augmenter do
-    RoadForest::Augment::Augmenter.new.tap do |augmenter|
-      augmenter.router = router
-      augmenter.canonical_uri = Addressable::URI.parse("http://example.com/a")
-    end
+    RoadForest::Augment::Augmenter.new(service_host)
   end
 
   subject :augmented_graph do
@@ -59,6 +69,9 @@ describe RoadForest::Augment::Affordance do
       subject.should match_query {
         pattern [:node, RDF.type, Af.Update]
         pattern [:node, Af.target, EX.a]
+        pattern [:node, Af.payload, :payload_root ]
+        pattern [:payload_root, Path.forward, :seg1 ]
+        pattern [:seg1, Path.predicate, EX.b ]
       }
     end
 
@@ -66,10 +79,24 @@ describe RoadForest::Augment::Affordance do
       subject.should match_query {
         pattern [:node, RDF.type, Af.Create]
         pattern [:node, Af.target, EX.a]
+        pattern [:node, Af.payload, :payload_root ]
+        pattern [:payload_root, Path.forward, :seg1 ]
+        pattern [:seg1, Path.predicate, EX.val ]
       }
     end
 
-    it "should add Delete affordance"
-    it "should add Navigable affordance to child"
+    it "should add Remove affordance" do
+      subject.should match_query {
+        pattern [:node, RDF.type, Af.Remove ]
+        pattern [:node, Af.target, EX.a ]
+      }
+    end
+
+    it "should add Navigate affordance to child" do
+      subject.should match_query {
+        pattern [:node, RDF.type, Af.Navigate ]
+        pattern [:node, Af.target, EX["a/b/1"] ]
+      }
+    end
   end
 end