roadforest 0.1 → 0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f4089bbfd4e58f956b5088ab646d62d904f11120
-  data.tar.gz: ebbccc85db766f417254b23aee95d022392e1b58
+  metadata.gz: c6aad7c24680d035ff3f8a2a72d660888d400be6
+  data.tar.gz: 4ed267799005efaba995beab6a5adfff4e171021
 SHA512:
-  metadata.gz: ecbf4fd992414ab2b73de911097455ef4712fbb9cb0c6f7bd7316a62abad9ca7b12ea5415b33817aaf9fc3bf83731500e684fe1099fa9ac217247ce94fe66883
-  data.tar.gz: 0a4125f562e7c390e5a515e4e06ba9099bd50268fa596734de825bce26c038d85c612594bc2b4db5ec521506430db1797e4ba3d3e772604f71de3c2a314d0c07
+  metadata.gz: c1a97a99c84940a429ebf824b919704d336d21d28a7113c0663a35dbc37ee451be3af7a6913b45e915a75d0d1f5fbf69ef2cc6a684df1d3f5a389f65526f1d62
+  data.tar.gz: 986679ca8ed11258a435a0f7b14d9f79b91487e7a2ec16dc2712b944fac032c5bd037a511725f62bc350f3c770401558b0b54ae76955710ade5f613fa4338911

data/examples/file-management.rb

@@ -1,3 +1,4 @@
+require 'roadforest-server'
 require 'rdf/vocab/skos'
 
 module FileManagementExample
@@ -17,14 +18,16 @@ module FileManagementExample
 
   class Application < RoadForest::Application
     def setup
-      router.add         :root,              [],                    :read_only,  Models::Navigation
-      router.add         :unresolved_needs,  ["unresolved_needs"],  :parent,     Models::UnresolvedNeedsList
-      router.add_traced  :need,              ["needs",'*'],         :leaf,       Models::Need
-      router.add         :file_content,      ["files","*"],         :leaf,       Models::NeedContent
+      router.add         :root,              [],                    :read_only,  Interfaces::Navigation
+      router.add         :unresolved_needs,  ["unresolved_needs"],  :parent,     Interfaces::UnresolvedNeedsList
+      router.add_traced  :need,              ["needs",'*'],         :leaf,       Interfaces::Need
+      router.add         :file_content,      ["files","*"],         :leaf,       RoadForest::Interface::Blob do |route|
+        route.content_engine = RoadForest::ContentHandling.plaintext_engine
+      end
     end
 
-    module Models
-      class Navigation < RoadForest::RDFModel
+    module Interfaces
+      class Navigation < RoadForest::Interface::RDF
         def exists?
           true
         end
@@ -47,7 +50,7 @@ module FileManagementExample
         end
       end
 
-      class UnresolvedNeedsList < RoadForest::RDFModel
+      class UnresolvedNeedsList < RoadForest::Interface::RDF
         def exists?
           true
         end
@@ -65,7 +68,7 @@ module FileManagementExample
           graph.add_list(:lc, "needs") do |list|
             services.file_records.each do |record|
               if !record.resolved
-                need = copy_model(graph, :need, '*' => [record.name])
+                need = copy_interface(graph, :need, '*' => [record.name])
                 need[:lc, :name]
                 need[:lc, :digest]
 
@@ -76,11 +79,7 @@ module FileManagementExample
         end
       end
 
-      class NeedContent < RoadForest::BlobModel
-        add_type TypeHandlers::Handler.new, "text/plain"
-      end
-
-      class Need < RoadForest::RDFModel
+      class Need < RoadForest::Interface::RDF
         def data
           @data = services.file_records.find do |record|
             record.name == params.remainder

data/lib/roadforest-client.rb

@@ -0,0 +1,3 @@
+require 'roadforest-common'
+require 'roadforest/remote-host'
+require 'roadforest/source-rigor'

data/lib/roadforest-common.rb

@@ -0,0 +1,2 @@
+require 'roadforest/content-handling'
+require 'roadforest/graph'

data/lib/roadforest-server.rb

@@ -0,0 +1,7 @@
+require 'roadforest-common'
+require 'roadforest/server'
+require 'roadforest/application'
+require 'roadforest/augmentations'
+require 'roadforest/authorization'
+require 'roadforest/interfaces'
+require 'roadforest/resource'

data/lib/roadforest-testing.rb

@@ -0,0 +1 @@
+require 'roadforest/test-support'

data/lib/roadforest/application.rb

@@ -6,14 +6,14 @@ end
 require 'roadforest/application/dispatcher'
 require 'roadforest/application/path-provider'
 require 'roadforest/application/services-host'
-require 'roadforest/resource/rdf'
-require 'roadforest/content-handling/engine'
-require 'roadforest/rdf/normalization'
+require 'roadforest/resource'
+require 'roadforest/content-handling/common-engines'
+require 'roadforest/graph/normalization'
 require 'roadforest/authorization'
 
 module RoadForest
   class Application
-    include RDF::Normalization
+    include Graph::Normalization
 
     def initialize(canonical_host, services = nil, configuration = nil, dispatcher = nil)
       @canonical_host = normalize_resource(canonical_host)
@@ -28,7 +28,7 @@ module RoadForest
     def setup
     end
 
-    attr_accessor :services, :canonical_host
+    attr_accessor :services, :canonical_host, :default_content_engine
 
     alias router dispatcher
 
@@ -36,8 +36,10 @@ module RoadForest
     def services=(service_host)
       @services = service_host
       service_host.application = self
-      @services.canonical_host = canonical_host
-      @services.router = PathProvider.new(@dispatcher)
+    end
+
+    def default_content_engine
+      @default_content_engine || ContentHandling.rdf_engine
     end
   end
 end

data/lib/roadforest/application/dispatcher.rb

@@ -1,5 +1,6 @@
 require 'webmachine'
 require 'roadforest/application/route-adapter'
+require 'roadforest/resource'
 
 module RoadForest
   class Dispatcher < Webmachine::Dispatcher
@@ -15,82 +16,57 @@ module RoadForest
       @route_names.fetch(name)
     end
 
-    def add_route(name, path_spec, resource_type, model_class, bindings = nil, &block)
-      if trace_by_default
-        return add_traced_route(name, path_spec, resource_type, model_class, bindings, &block)
-      else
-        return add_untraced_route(name, path_spec, resource_type, model_class, bindings, &block)
-      end
+    def default_content_engine
+      @application.default_content_engine
     end
-    alias add add_route
 
-    def add_untraced_route(name, path_spec, resource_type, model_class, bindings = nil, &block)
-      resource = bundle_typed_resource(resource_type, model_class, name)
-      resource_route(resource, name, path_spec, bindings, &block)
+    def path_provider
+      @path_provider ||= PathProvider.new(self)
     end
-    alias add_untraced add_untraced_route
 
-    def add_traced_route(name, path_spec, resource_type, model_class, bindings = nil, &block)
-      resource = bundle_traced_resource(resource_type, model_class, name)
-      resource_route(resource, name, path_spec, bindings, &block)
+    def services
+      @application.services
     end
-    alias add_traced add_traced_route
 
-    def resource_route(resource, name, path_spec, bindings)
-      route = Route.new(path_spec, resource, bindings || {})
-      yield route if block_given?
-      @route_names[name] = route
-      @routes << route
-      route
-    end
+    # Add a named route to the dispatcher - the 90% case is handled by passing
+    # arguments in, but more control is available but manipulating the
+    # RouteBinding object used to create the Route and ResourceAdapter
+    #
+    # @yields [RouteBinding] temporary configuration object
+    def add_route(name=nil, path_spec=nil, resource_type=nil, interface_class=nil)
+      binder = Application::RouteBinding.new(self)
 
-    def bundle_typed_resource(resource_type, model_class, route_name)
-      resource_class = Resource.get(resource_type)
-      Application::RouteAdapter.new(route_name, resource_class, model_class) do |adapter|
-        adapter.application = application
-      end
-    end
+      binder.route_name = name
+      binder.path_spec = path_spec
+      binder.resource_type = resource_type
+      binder.interface_class = interface_class
 
-    def bundle_traced_resource(resource_type, model_class, route_name)
-      resource_class = Resource.get(resource_type)
-      Application::RouteAdapter.new(route_name, resource_class, model_class) do |adapter|
-        adapter.application = application
-        adapter.trace = true
-      end
+      yield binder if block_given?
+
+      binder.validate!
+
+      @route_names[name] = binder.route
+      @routes << binder.route
+      binder.route
     end
+    alias add add_route
 
-    class Route < Webmachine::Dispatcher::Route
-      # Create a complete URL for this route, doing any necessary variable
-      # substitution.
-      # @param [Hash] vars values for the path variables
-      # @return [String] the valid URL for the route
-      def build_path(vars = nil)
-        vars ||= {}
-        "/" + path_spec.map do |segment|
-          case segment
-          when '*',Symbol
-            vars.fetch(segment)
-          when String
-            segment
-          end
-        end.join("/")
+    # @deprecated Just use add_route
+    def add_untraced_route(name = nil, path_spec = nil, resource_type = nil, interface_class = nil)
+      add_route(name, path_spec, resource_type, interface_class) do |binder|
+        binder.trace = false
+        yield binder if block_given?
       end
+    end
+    alias add_untraced add_untraced_route
 
-      def build_params(vars = nil)
-        vars ||= {}
-        params = Application::Parameters.new
-        path_set = Hash[path_spec.find_all{|segment| segment.is_a? Symbol}.map{|seg| [seg, true]}]
-        vars.to_hash.each do |key, value|
-          if(path_set.has_key?(key))
-            params.path_info[key] = value
-          elsif(key == '*')
-            params.path_tokens = value
-          else
-            params.query_params[key] = value
-          end
-        end
-        params
+    # @deprecated Just use add_route
+    def add_traced_route(name, path_spec, resource_type, interface_class, bindings = nil, &block)
+      add_route(name, path_spec, resource_type, interface_class) do |binder|
+        binder.trace = true
+        yield binder if block_given?
       end
     end
+    alias add_traced add_traced_route
   end
 end

data/lib/roadforest/application/parameters.rb

@@ -1,6 +1,6 @@
 module RoadForest
   class Application
-    #Parameters extracted from a URL, which a model object can use to identify
+    #Parameters extracted from a URL, which a interface object can use to identify
     #the resource being discussed
     class Parameters
       def initialize

data/lib/roadforest/application/path-provider.rb

@@ -22,10 +22,10 @@ module RoadForest
       Webmachine::Request.new(method, url, headers, body)
     end
 
-    def model_for(name, vars = nil)
+    def interface_for(name, vars = nil)
       route = @dispatcher.route_for_name(name)
       params = route.build_params(vars)
-      route.resource.build_model(params)
+      route.resource.build_interface(params)
     end
   end
 end

data/lib/roadforest/application/route-adapter.rb

@@ -1,34 +1,146 @@
 module RoadForest
   class Application
-    class RouteAdapter
-      def initialize(route_name, resource_class, model_class)
-        @resource_class = resource_class
+    #Embedded in WebMachine's Routes to compose the object structure at need
+    class ResourceAdapter
+      attr_accessor :resource_builder, :interface_builder, :route_name, :router, :services, :content_engine, :trace, :router
 
-        @route_name = route_name
-        @model_class = model_class
-        @application = nil
-        @trace = false
-        yield self if block_given?
+      def <(klass)
+        if klass <= Webmachine::Resource
+          return true
+        else
+          return false
+        end
       end
-      attr_accessor :route_name, :resource_class, :model_class, :application, :trace
 
       def new(request, response)
-        resource = resource_class.new(request, response)
-        resource.model = build_model(resource.params)
-        resource.trace = trace
+        resource = resource_builder.call(request, response)
+        resource.interface = build_interface(resource.params)
+        resource.content_engine = content_engine || router.default_content_engine
+        resource.trace = trace?
         resource
       end
 
-      def build_model(params)
-        model_class.new(route_name, params, application.services)
+      def build_interface(params)
+        interface_builder.call(route_name, params, router, router.services)
       end
 
-      def <(klass)
-        if klass <= Webmachine::Resource
-          return true
+      def trace?
+        if @trace.nil?
+          router.trace_by_default
         else
-          return false
+          !!@trace
+        end
+      end
+    end
+
+    #Extension of Webmachine's Routes that allows for rendering url paths and
+    #parameter lists.
+    class Route < Webmachine::Dispatcher::Route
+      # Create a complete URL for this route, doing any necessary variable
+      # substitution.
+      # @param [Hash] vars values for the path variables
+      # @return [String] the valid URL for the route
+      def build_path(vars = nil)
+        vars ||= {}
+        "/" + path_spec.map do |segment|
+          case segment
+          when '*',Symbol
+            vars.fetch(segment)
+          when String
+            segment
+          end
+        end.join("/")
+      end
+
+      def build_params(vars = nil)
+        vars ||= {}
+        params = Application::Parameters.new
+        path_set = Hash[path_spec.find_all{|segment| segment.is_a? Symbol}.map{|seg| [seg, true]}]
+        vars.to_hash.each do |key, value|
+          if(path_set.has_key?(key))
+            params.path_info[key] = value
+          elsif(key == '*')
+            params.path_tokens = value
+          else
+            params.query_params[key] = value
+          end
+        end
+        params
+      end
+    end
+
+    class RouteBinding
+      def initialize(router)
+        @router = router
+      end
+
+      attr_accessor :route_name, :path_spec, :bindings, :guard
+      attr_accessor :resource_type, :interface_class, :services, :trace, :content_engine
+
+      def resource_builder
+        @resource_builder ||= proc do |request, response|
+          Resource.get(resource_type).new(request, response)
+        end
+      end
+
+      def build_resource(&block)
+        @resource_builder = block
+      end
+
+      def interface_builder
+        @interface_builder ||= proc do |name, params, router, services|
+          interface_class.new(name, params, router.path_provider, services)
+        end
+      end
+
+      def build_interface(&block)
+        @interface_builder = block
+      end
+
+      def route
+        @route ||=
+          begin
+            if guard.nil?
+              Route.new(path_spec, resource_adapter, bindings || {})
+            else
+              Route.new(path_spec, resource_adapter, bindings || {}, &guard)
+            end
+          end
+      end
+
+      def resource_adapter
+        @resource_adapter ||=
+          begin
+            ResourceAdapter.new.tap do |adapter|
+              adapter.router = @router
+              adapter.route_name = route_name
+              adapter.interface_builder = interface_builder
+              adapter.resource_builder = resource_builder
+              adapter.content_engine = content_engine
+              adapter.trace = trace
+            end
+          end
+      end
+
+      def validate!
+        problems = []
+
+        if @path_spec.nil?
+          problems << "Path specification is nil - no way to route URLs here."
+        end
+
+        if @resource_builder.nil? && @resource_type.nil?
+          problems << "No means provided to build a resource adapter: set resource_type or resource_builder"
+        end
+
+        if @interface_builder.nil? and @interface_class.nil?
+          problems << "No means provided to build an application interface: set interface_class or interface_builder"
+        end
+
+        unless problems.empty?
+          raise InvalidRouteDefinition, "Route invalid:\n  #{problems.join("  \n")}"
         end
+        return true
       end
     end
   end