roadforest 0.1 → 0.5

data/lib/roadforest/application/services-host.rb

@@ -26,10 +26,6 @@ module RoadForest
           end
       end
 
-      def type_handling
-        @type_handling ||= ContentHandling::Engine.default
-      end
-
       def logger
         @logger ||=
           begin

data/lib/roadforest/augment/affordance.rb

@@ -0,0 +1,78 @@
+require 'roadforest/augment/augmentation'
+require 'roadforest/graph/vocabulary'
+
+module RoadForest
+  module Augment
+    module Affordance
+      Af = Graph::Af
+
+      class Remove < Augmentation
+        register_for_subjects
+
+        def apply(term)
+          if term.resource.allowed_methods.include?("DELETE")
+            node = ::RDF::Node.new
+            yield [node, ::RDF.type, Af.Remove]
+            yield [node, Af.target, term.uri]
+          end
+        end
+      end
+
+      class Links < Augmentation
+        register_for_subjects
+        register_for_objects
+
+        def apply(term)
+          if term.uri.host != canonical_uri.hostname
+            return
+          end
+
+          case term.resource
+          when Webmachine::Dispatcher::NotFoundResource
+            node = ::RDF::Node.new
+            yield [node, ::RDF.type, Af.Null]
+            yield [node, Af.target, term.uri]
+          else
+            if term.resource.allowed_methods.include?("GET")
+              embeddable = ContentHandling::MediaTypeList.build(["image/jpeg"])
+
+              if embeddable.matches?(term.type_list)
+                node = ::RDF::Node.new
+                yield [node, ::RDF.type, Af.Embed]
+                yield [node, Af.target, term.uri]
+              else
+                node = ::RDF::Node.new
+                yield [node, ::RDF.type, Af.Navigate]
+                yield [node, Af.target, term.uri]
+              end
+            end
+          end
+        end
+      end
+
+      class Update < Augmentation
+        register_for_subjects
+
+        def apply(term)
+          if term.resource.allowed_methods.include?("PUT")
+            node = ::RDF::Node.new
+            yield [node, ::RDF.type, Af.Update]
+            yield [node, Af.target, term.uri]
+          end
+        end
+      end
+
+      class Create < Augmentation
+        register_for_subjects
+
+        def apply(term)
+          if term.resource.allowed_methods.include?("POST")
+            node = ::RDF::Node.new
+            yield [node, ::RDF.type, Af.Create]
+            yield [node, Af.target, term.uri]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roadforest/augment/augmentation.rb

@@ -0,0 +1,97 @@
+require 'roadforest/augment/augmenter'
+module RoadForest
+  module Augment
+    class Augmentation
+      def self.register_for_subjects
+        Augmenter.subject_augmentations_registry.add(self.name, self)
+      end
+
+      def self.register_for_objects
+        Augmenter.object_augmentations_registry.add(self.name, self)
+      end
+
+      def initialize(augmenter)
+        @augmenter = augmenter
+      end
+
+      def canonical_uri
+        @augmenter.canonical_uri
+      end
+
+      def router
+        @augmenter.router
+      end
+    end
+
+    class LazyResource
+      def initialize(uri, router)
+        @uri = uri
+        @router = router
+      end
+
+      attr_accessor :uri, :router
+
+      def request
+        @request ||= Webmachine::Request.new("GET", uri, {}, nil)
+      end
+
+      def response
+        @response ||= Webmachine::Response.new
+      end
+
+      def route
+        @route ||= router.find_route(request)
+      end
+
+      def resource
+        @resource ||= router.find_resource(request, response)
+      end
+
+      def type_list
+        @type_list ||=
+          resource.content_types_provided.inject(ContentHandling::MediaTypeList.new) do |list, (type, method)|
+            list.add_header_val(type)
+          end
+      end
+    end
+
+    class Process
+      attr_accessor :base_graph, :subjects
+
+      def initialize(base_graph)
+        @base_graph = base_graph
+      end
+
+      def target_graph
+        @target_graph ||=
+          begin
+            ::RDF::Repository.new.tap do |graph|
+              base_graph.each_statement do |stmt|
+                graph << stmt
+              end
+            end
+          end
+      end
+
+      def subjects
+        @subjects ||= base_graph.subjects.select{|obj| ::RDF::URI === obj }
+      end
+
+      def objects
+        @objects ||= base_graph.objects.select{|obj| ::RDF::URI === obj}
+      end
+
+      def subject_resources(router)
+        subjects.map do |uri|
+          LazyResource.new(uri, router)
+        end
+      end
+
+      def object_resources(router)
+        objects.map do |uri|
+          LazyResource.new(uri, router)
+        end
+      end
+    end
+  end
+end

data/lib/roadforest/augment/augmenter.rb

@@ -0,0 +1,54 @@
+require 'rdf'
+require 'roadforest/utility/class-registry'
+
+module RoadForest
+  module Augment
+    class Augmenter
+      attr_accessor :router
+
+      def self.subject_augmentations_registry
+        @subject_registry ||= Utility::ClassRegistry.new(self, "subject augmentation")
+      end
+
+      def self.object_augmentations_registry
+        @object_registry ||= Utility::ClassRegistry.new(self, "object augmentation")
+      end
+
+      def subject_augmentations
+        self.class.subject_augmentations_registry.map_classes do |klass|
+          klass.new(self)
+        end
+      end
+
+      def object_augmentations
+        self.class.object_augmentations_registry.map_classes do |klass|
+          klass.new(self)
+        end
+      end
+
+      attr_accessor :canonical_uri
+
+      def augment(graph)
+        augmenting = Augment::Process.new(graph)
+
+        augmenting.subject_resources(router).each do |resource|
+          subject_augmentations.each do |augmentation|
+            augmentation.apply(resource) do |statement|
+              augmenting.target_graph << statement
+            end
+          end
+        end
+
+        augmenting.object_resources(router).each do |resource|
+          object_augmentations.each do |augmentation|
+            augmentation.apply(resource) do |statement|
+              augmenting.target_graph << statement
+            end
+          end
+        end
+
+        augmenting.target_graph
+      end
+    end
+  end
+end

data/lib/roadforest/augmentations.rb

@@ -0,0 +1 @@
+require 'roadforest/augment/affordance'

data/lib/roadforest/content-handling.rb

@@ -0,0 +1 @@
+require 'roadforest/content-handling/common-engines'

data/lib/roadforest/content-handling/common-engines.rb

@@ -0,0 +1,67 @@
+require 'roadforest/content-handling/engine'
+
+module RoadForest
+  module ContentHandling
+    class << self
+      def rdf_engine
+        @rdf_engine ||=
+          begin
+            require 'roadforest/type-handlers/jsonld'
+            require 'roadforest/type-handlers/rdfa'
+            rdfa = RoadForest::TypeHandlers::RDFa.new
+            jsonld = RoadForest::TypeHandlers::JSONLD.new
+
+            ContentHandling::Engine.new.tap do |engine|
+              engine.add rdfa, "text/html;q=1;rdfa=1"
+              engine.add rdfa, "application/xhtml+xml;q=1;rdfa=1"
+              engine.add jsonld, "application/ld+json"
+              engine.add rdfa, "text/html;q=0.5"
+              engine.add rdfa, "application/xhtml+xml;q=0.5"
+            end
+          end
+      end
+
+      def plaintext_engine
+        @plaintext_engine ||=
+          begin
+            require 'roadforest/type-handlers/handler'
+            text = RoadForest::TypeHandlers::Handler.new
+
+            ContentHandling::Engine.new.tap do |engine|
+              engine.add text, "text/plain"
+            end
+          end
+      end
+
+      # @warning This is only the most nebulous beginning of image handling
+      def images_engine
+        @image_engine ||=
+          begin
+            require 'roadforest/type-handlers/handler'
+            data = RoadForest::TypeHandlers::Handler.new
+
+            RoadForest::ContentHandling::Engine.new.tap do |engine|
+              engine.add data, "image/jpeg"
+              engine.add data, "image/png;q=0.9"
+              engine.add data, "image/gif;q=0.7"
+            end
+          end
+      end
+
+      # @warning This is only the most nebulous beginning of image handling
+      def graphics_engine
+        @graphics_engine ||=
+          begin
+            require 'roadforest/type-handlers/handler'
+            data = RoadForest::TypeHandlers::Handler.new
+
+            RoadForest::ContentHandling::Engine.new.tap do |engine|
+              engine.add data, "image/png"
+              engine.add data, "image/gif;q=0.9"
+              engine.add data, "image/jpeg;q=0.7"
+            end
+          end
+      end
+    end
+  end
+end

data/lib/roadforest/content-handling/engine.rb

@@ -46,18 +46,6 @@ module RoadForest
         end
       end
 
-      def self.default
-        require 'roadforest/content-handling/type-handlers/jsonld'
-        require 'roadforest/content-handling/type-handlers/rdfa'
-        self.new.tap do |engine|
-          engine.add RoadForest::MediaType::Handlers::RDFa.new, "text/html;q=1;rdfa=1"
-          engine.add RoadForest::MediaType::Handlers::RDFa.new, "application/xhtml+xml;q=1;rdfa=1"
-          engine.add RoadForest::MediaType::Handlers::JSONLD.new, "application/ld+json"
-          engine.add RoadForest::MediaType::Handlers::RDFa.new, "text/html;q=0.5"
-          engine.add RoadForest::MediaType::Handlers::RDFa.new, "application/xhtml+xml;q=0.5"
-        end
-      end
-
       def initialize
         @renderers = TypeHandlerList.new("provide")
         @parsers = TypeHandlerList.new("accept")
@@ -74,14 +62,14 @@ module RoadForest
 
       def add_parser(object, type)
         type = MediaType.parse(type)
-        wrapper = RoadForest::MediaType::Handlers::Wrap::Parse.new(type, object)
+        wrapper = RoadForest::ContentHandling::Wrap::Parse.new(type, object)
         parsers.add(wrapper)
       end
       alias accept add_parser
 
       def add_renderer(object, type)
         type = MediaType.parse(type)
-        wrapper = RoadForest::MediaType::Handlers::Wrap::Render.new(type, object)
+        wrapper = RoadForest::ContentHandling::Wrap::Render.new(type, object)
         renderers.add(wrapper)
       end
       alias provide add_renderer

data/lib/roadforest/content-handling/handler-wrap.rb

@@ -1,43 +1,41 @@
 module RoadForest
-  module MediaType
-    module Handlers
-      module Wrap
-        class Wrapper
-          def initialize(type, handler)
-            @type = type
-            @handler = handler
-          end
-          attr_reader :type, :handler
+  module ContentHandling
+    module Wrap
+      class Wrapper
+        def initialize(type, handler)
+          @type = type
+          @handler = handler
+        end
+        attr_reader :type, :handler
 
-          def local_to_network(base_uri, network)
-            @handler.local_to_network(base_uri, network)
-          end
-          alias from_graph local_to_network
+        def local_to_network(base_uri, network)
+          @handler.local_to_network(base_uri, network)
+        end
+        alias from_graph local_to_network
 
-          def network_to_local(base_uri, source)
-            @handler.network_to_local(base_uri, source)
-          end
-          alias to_graph network_to_local
+        def network_to_local(base_uri, source)
+          @handler.network_to_local(base_uri, source)
         end
+        alias to_graph network_to_local
+      end
 
-        class Render < Wrapper
-          def call(resource)
-            @handler.render_for(resource)
-          end
+      class Render < Wrapper
+        def call(resource)
+          @handler.render_for(resource)
+        end
 
-          def content_type_header
-            @type.content_type_header
-          end
+        def content_type_header
+          @type.content_type_header
         end
+      end
 
-        class Parse < Wrapper
-          def call(resource)
-            @handler.parse_for(resource)
-          end
+      class Parse < Wrapper
+        def call(resource)
+          @handler.parse_for(resource)
+        end
 
-          def add_child(resource)
-            @handler.add_child_to(resource)
-          end
+        def add_child(resource)
+          @handler.add_child_to(resource)
         end
       end
     end

data/lib/roadforest/content-handling/media-type.rb

@@ -190,6 +190,11 @@ module RoadForest
         end
       end
 
+      def matches?(other)
+        type = best_match_from(other)
+        include?(type) && other.include?(type)
+      end
+
       def by_precedence
         self.sort do |left, right|
           right.precedence_index <=> left.precedence_index
@@ -201,6 +206,7 @@ module RoadForest
       # @param [String] choice the acceptable item
       def add(type)
         @list << type
+        self
       end
 
       # Given a raw acceptable value from an acceptance header,