roadforest 0.1 → 0.5

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

@@ -1,4 +1,4 @@
-require 'roadforest/rdf/graph-store'
+require 'roadforest/source-rigor/graph-store'
 require 'roadforest/remote-host'
 require 'roadforest/test-support/http-client'
 module RoadForest::TestSupport
@@ -9,7 +9,7 @@ module RoadForest::TestSupport
     end
 
     def build_graph_store
-      RoadForest::RDF::GraphStore.new
+      RoadForest::SourceRigor::GraphStore.new
     end
 
     def http_client

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

@@ -0,0 +1,74 @@
+module RoadForest
+  module TypeHandlers
+    class Handler
+      def network_to_local(base_uri, network)
+        return network
+      end
+
+      def local_to_network(base_uri, local)
+        return local
+      end
+
+      def parse_for(resource)
+        source = resource.request_body
+        interface = resource.interface
+        input_data = network_to_local(interface.my_url, source)
+
+        update_interface(interface, input_data)
+
+        renderer = resource.content_engine.choose_renderer(resource.request_accept_header)
+        body = renderer.local_to_network(interface.my_url, interface.response_data)
+
+        build_response(resource)
+      end
+
+      def render_for(resource)
+        interface = resource.interface
+        output_data = get_output(interface)
+        local_to_network(interface.my_url,  output_data)
+      end
+
+      def add_child_to(resource)
+        interface = resource.interface
+        source = resource.request_body
+        input_data = network_to_local(interface.my_url, source)
+
+        child_for_interface(resource.interface, input_data)
+
+        build_response(resource)
+      end
+
+      def build_response(resource)
+        interface = resource.interface
+
+        renderer = resource.content_engine.choose_renderer(resource.request_accept_header)
+        body = renderer.local_to_network(interface.my_url, interface.response_data)
+
+        resource.response_content_type = renderer.content_type_header
+        resource.response_body = body
+        if interface.response_location
+          resource.redirect_to(interface.response_location)
+        end
+      end
+
+      def child_for_interface(interface, data)
+        interface.add_child(data)
+        interface.processed
+      end
+
+      def update_interface(interface, input_data)
+        result = interface.update(input_data)
+        interface.response_data = result
+        interface.processed
+        result
+      end
+
+      def get_output(interface)
+        result = interface.retrieve
+        interface.response_data = result
+        interface.processed
+        result
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'json/ld'
+require 'roadforest/type-handlers/rdf-handler'
+module RoadForest
+  module TypeHandlers
+    #application/ld+json
+    class JSONLD < RDFHandler
+      include Graph::Normalization
+
+      def local_to_network(base_uri, rdf)
+        raise "Invalid base uri: #{base_uri}" if base_uri.nil?
+        prefixes = relevant_prefixes_for_graph(rdf)
+        prefixes.keys.each do |prefix|
+          prefixes[prefix.to_sym] = prefixes[prefix]
+        end
+        JSON::LD::Writer.buffer(:base_uri => base_uri.to_s,
+                                :prefixes => prefixes) do |writer|
+          rdf.each_statement do |statement|
+            writer << statement
+          end
+                                end
+      end
+
+      def network_to_local(base_uri, source)
+        raise "Invalid base uri: #{base_uri.inspect}" if base_uri.nil?
+        graph = ::RDF::Graph.new
+        reader = JSON::LD::Reader.new(source.to_s, :base_uri => base_uri.to_s)
+        reader.each_statement do |statement|
+          graph.insert(statement)
+        end
+        graph
+      end
+    end
+  end
+end

data/lib/roadforest/type-handlers/rdf-handler.rb

@@ -0,0 +1,36 @@
+require 'roadforest/type-handlers/handler'
+require 'roadforest/graph/normalization'
+module RoadForest
+  module TypeHandlers
+    class RDFHandler < Handler
+      include Graph::Normalization
+
+      def get_output(interface)
+        graph = super
+        root_uri = interface.canonical_uri
+
+        graph.each_statement do |statement|
+          original = statement.dup
+          if ::RDF::URI === statement.subject and statement.subject.relative?
+            statement.subject = normalize_resource(root_uri.join(statement.subject))
+          end
+
+          if ::RDF::URI === statement.object and statement.object.relative?
+            statement.object = normalize_resource(root_uri.join(statement.object))
+          end
+
+          if statement != original
+            graph.delete(original)
+            graph.insert(statement)
+          end
+        end
+        graph
+      end
+
+      def child_for_interface(interface, data)
+        interface.add_graph_child(data)
+        interface.processed
+      end
+    end
+  end
+end

data/lib/roadforest/{content-handling/type-handlers → type-handlers}/rdfa-writer.rb

@@ -2,7 +2,7 @@ require 'cgi'
 require 'roadforest/debug'
 require 'rdf/rdfa'
 
-module RoadForest::MediaType
+module RoadForest::TypeHandlers
   ##
   # An RDFa 1.1 serialiser in Ruby. The RDFa serializer makes use of Haml templates, allowing runtime-replacement with alternate templates. Note, however, that templates should be checked against the W3C test suite to ensure that valid RDFa is emitted.
   #
@@ -134,7 +134,7 @@ module RoadForest::MediaType
     #
     # @return [void]
     def write_epilogue
-      require 'roadforest/content-handling/type-handlers/rdfa-writer/render-engine'
+      require 'roadforest/type-handlers/rdfa-writer/render-engine'
       @base_uri = RDF::URI(@options[:base_uri]) if @options[:base_uri]
       @lang = @options[:lang]
       @debug = @options[:debug]

data/lib/roadforest/{content-handling/type-handlers → type-handlers}/rdfa-writer/document-environment.rb

@@ -1,11 +1,9 @@
-require 'roadforest/content-handling/type-handlers/rdfa-writer/render-environment'
-module RoadForest::MediaType
+require 'roadforest/type-handlers/rdfa-writer/render-environment'
+
+module RoadForest::TypeHandlers
   class RDFaWriter
     class DocumentEnvironment < RenderEnvironment
       attr_accessor :subject_terms, :title, :prefixes, :lang, :base
-      def yielded(item)
-        @_engine.render(item)
-      end
 
       def subjects
         enum_for(:each_subject_environment)
@@ -13,7 +11,7 @@ module RoadForest::MediaType
 
       def each_subject_environment
         subject_terms.each do |term|
-          yield @_engine.subject_env(term)
+          yield subject_env(term)
         end
       end
 
@@ -21,14 +19,17 @@ module RoadForest::MediaType
         %w{doc}
       end
 
-      def prefix
-        @prefix ||=
+      def build_prefix_header(prefixes)
           if prefixes.empty?
             nil
           else
             prefixes.keys.map {|pk| "#{pk}: #{prefixes[pk]}"}.sort.join(" ")
           end.tap{|prefix| add_debug {"\nserialize: prefixes: #{prefixes.inspect} prefix src: #{prefix.inspect}"}}
       end
+
+      def prefix
+        @prefix ||= build_prefix_header(prefixes)
+      end
     end
   end
 end

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

@@ -0,0 +1,312 @@
+require 'roadforest/utility/class-registry'
+require 'roadforest/graph/vocabulary'
+
+module RoadForest
+  module AffordanceClient
+    Af = Graph::Af
+    def all_affordances
+      @all_affordances ||=
+        [
+          Af.Affordance,
+          Af.Null,
+          Af.Safe,
+          Af.Idempotent,
+          Af.Unsafe,
+          Af.Navigate,
+          Af.Embed,
+          Af.Metadata,
+          Af.Update,
+          Af.Remove,
+          Af.Create,
+          Af.Mutate,
+      ]
+    end
+
+    def affordance_present(aff)
+      ::RDF::Query.new do
+        pattern [:any, ::RDF.type, aff ]
+      end
+    end
+
+    def has_affordance(node, type)
+      if type.is_a? Symbol
+        type = Af[type]
+      end
+      ::RDF::Query.new do
+        pattern([:node, ::RDF.type, type, nil])
+        pattern([:node, Af.target, node, nil])
+      end
+    end
+
+    def payload_has_param(node)
+      ::RDF::Query.new do
+        pattern([:node, Af.payload, :context, nil])
+        pattern([ :param, ::RDF.type, Af.Parameter, :context ])
+      end
+    end
+
+    def query_matches(query, graph)
+      return (not graph.first(query).nil?)
+    end
+
+    def affordances_in_graph?(graph)
+      all_affordances.each do |aff|
+        return true if query_matches(affordance_present(aff), graph)
+      end
+      return false
+    end
+
+    def affordance_node?(node, graph)
+      query = ::RDF::Query.new do
+        pattern [node, ::RDF.type, :type]
+      end
+      !!( query.execute(graph).find do |solution|
+        all_affordances.include?(solution[:type])
+      end)
+    end
+
+    def affordance_type_in_graph?(node, type, graph)
+      #puts "\n#{__FILE__}:#{__LINE__} => \n#{graph.dump(:nquads)}"
+      query_matches(has_affordance(node, type).tap{|value|
+        #puts "#{__FILE__}:#{__LINE__} => #{[value.patterns,
+        #value.execute(graph)].inspect}"
+      }, graph).tap{|value|
+        #puts "#{__FILE__}:#{__LINE__} => #{value.inspect}"
+      }
+    end
+
+    def parameterized_navigation_affordance_in_graph?(node, graph)
+      return false #to be implemented
+      query_matches(has_affordance(node, :Navigate) + payload_has_param(node), graph)
+    end
+  end
+
+  module TypeHandlers
+    class RDFaWriter
+      class DecorationSet
+        def initialize
+          @names = EnvironmentDecorator.all_names
+        end
+        attr_accessor :names
+
+        def decoration_for(env)
+          names.inject(env) do |env, name|
+            EnvironmentDecorator[name].perhaps_decorate(env)
+          end
+        end
+      end
+
+      class EnvironmentDecorator
+        extend Utility::ClassRegistry::Registrar
+
+        class << self
+          def registry_purpose
+            "render environment decoration"
+          end
+
+          def decorates(klass)
+            register(self.name)
+            @decorated_class = klass
+            methods = klass.instance_methods
+            methods -= self.instance_methods
+            methods.each do |method|
+              define_method(method) do |*args, &block|
+                @_decorated_.__send__(method, *args, &block)
+              end
+            end
+          end
+
+          def can_decorate?(env)
+            return (env._base_env_.class <= @decorated_class)
+          end
+
+          def perhaps_decorate(env)
+            if can_decorate?(env)
+              self.new(env)
+            else
+              env
+            end
+          end
+
+        end
+
+        def initialize(env)
+          @_decorated_ = env
+          setup
+        end
+
+        def setup
+        end
+
+        def like_a?(klass)
+          is_a?(klass) || _decorated_.like_a?(klass)
+        end
+
+        attr_reader :_decorated_
+      end
+
+      class RDFPostCurie < RenderEnvironment
+        def initialize(engine, kind, uri)
+          super(engine)
+          @kind, @uri = kind, uri
+        end
+
+        attr_reader :kind, :uri
+
+        def curie
+          @curie ||= get_curie(uri)
+        end
+
+        def reduced?
+          curie != uri
+        end
+
+        def prefix
+          @prefix ||= curie.split(":").first
+        end
+
+        def suffix
+          @suffix ||= curie.split(":").last
+        end
+
+        def template_kinds
+          %w{rdfpost-curie}
+        end
+      end
+
+      class AffordanceDecorator < EnvironmentDecorator
+        include AffordanceClient
+        extend AffordanceClient
+
+        def graph
+          _engine.graph
+        end
+
+        def affordance?
+          true
+        end
+
+        def rdfpost_curie(kind, uri)
+          curie = RDFPostCurie.new(_engine, kind, uri)
+
+          _engine.render(curie)
+        end
+
+        def template_kinds
+          _base_env_.template_kinds.map{|kind| "affordance-" + kind} + _base_env_.template_kinds
+        end
+      end
+
+      class DocumentAffordanceDecorator < AffordanceDecorator
+        decorates DocumentEnvironment
+
+        def self.can_decorate?(env)
+          return false unless env._base_env_.class <= DocumentEnvironment
+          affordances_in_graph?(env._engine.graph)
+        end
+
+
+        def subjects
+          _decorated_.subjects.reject do |subject_env|
+            affordance_node?(subject_env.subject, graph)
+          end
+        end
+
+        def prefixes
+          dec_prefixes = _decorated_.prefixes
+
+          dec_prefixes.keys.find_all do |key|
+            dec_prefixes[key] == Af.to_uri
+          end.each do |key|
+            dec_prefixes.delete(key)
+          end
+          dec_prefixes
+        end
+
+        def prefix
+          @prefix ||= build_prefix_header(prefixes)
+        end
+      end
+
+      class SubjectAffordanceDecorator < AffordanceDecorator
+        decorates SubjectEnvironment
+
+        def self.can_decorate?(env)
+          return false unless env._base_env_.class <= SubjectEnvironment
+          return false unless env.parent.like_a? AffordanceDecorator
+
+          return (
+            [:Update, :Remove, :Create].find do |type|
+            affordance_type_in_graph?(env.subject, type, env._engine.graph)
+            end || parameterized_navigation_affordance_in_graph?(env.subject, env._engine.graph))
+        end
+
+        def predicate_nodes
+          @predicate_nodes ||=
+            begin
+              [].tap do |nodes|
+                each_predicate do |pred|
+                  pred.each_object do |object|
+                    subj = _engine.subject_env(object)
+                    next if subj.nil?
+                    subj.rel = get_curie(pred.predicate)
+                    nodes << subj
+                  end
+                end
+              end
+            end
+          @predicate_nodes.enum_for(:each)
+        end
+
+        def prefixes
+          _engine.prefixes
+        end
+
+        def attrs
+          _decorated_.attrs.merge(
+            :method => "POST", :action => subject.join("put")
+          )
+        end
+      end
+
+      class PropertyAffordanceDecorator < AffordanceDecorator
+        decorates PropertyEnvironment
+
+        def self.can_decorate?(env)
+          return false unless (env._base_env_.class <= PropertyEnvironment)
+          return false unless (env.parent.like_a? AffordanceDecorator)
+          return true
+        end
+
+      end
+
+      class ObjectAffordanceDecorator < AffordanceDecorator
+        decorates ObjectEnvironment
+
+        def self.can_decorate?(env)
+          return false unless env._base_env_.class <= ObjectEnvironment
+          return false unless env.parent.like_a? AffordanceDecorator
+          return true
+        end
+
+        def label_attrs
+          {}
+        end
+
+        def type_uri
+          if object.literal? and object.datatype?
+            object.datatype
+          end
+        end
+
+        def input_attrs(value)
+          @_decorated_.attrs.merge(
+            :name => "ol",
+            :content => value,
+            :value => value,
+          )
+        end
+      end
+    end
+  end
+end