roadforest 0.5 → 0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c6aad7c24680d035ff3f8a2a72d660888d400be6
-  data.tar.gz: 4ed267799005efaba995beab6a5adfff4e171021
+  metadata.gz: 6db5d72add13365fd11e006d8942448265f13f61
+  data.tar.gz: 85a7105fe1995e4a340c6540e4f02d4f84c5d900
 SHA512:
-  metadata.gz: c1a97a99c84940a429ebf824b919704d336d21d28a7113c0663a35dbc37ee451be3af7a6913b45e915a75d0d1f5fbf69ef2cc6a684df1d3f5a389f65526f1d62
-  data.tar.gz: 986679ca8ed11258a435a0f7b14d9f79b91487e7a2ec16dc2712b944fac032c5bd037a511725f62bc350f3c770401558b0b54ae76955710ade5f613fa4338911
+  metadata.gz: 6eaa87181e7ee19771dd8e3e561afac00885dee1b9f49b27978423e1d6850ca3bd9768bd21861f528b0327fb8732b5d109bdb03a852812ce3d97cd8a8ef2648b
+  data.tar.gz: 441c94a9a790b7e6e94978a8c4ca5407a343562ad106c2a45d86ae6f7b09d6e90afb888501e1b401c03c7517de3000f5aa437802bd70e5cd6b0399cff6490b05

data/examples/file-management.rb

@@ -3,7 +3,9 @@ require 'rdf/vocab/skos'
 
 module FileManagementExample
   module Vocabulary
-    class LC < ::RDF::Vocabulary("http://lrdesign.com/vocabularies/logical-construct#"); end
+    class LC < ::RDF::Vocabulary("http://lrdesign.com/vocabularies/logical-construct#")
+      property :name
+    end
   end
 
   class ServicesHost < ::RoadForest::Application::ServicesHost
@@ -11,13 +13,7 @@ module FileManagementExample
 
     def initialize
       @file_records = []
-    end
-  end
-
-  FileRecord = Struct.new(:name, :resolved)
 
-  class Application < RoadForest::Application
-    def setup
       router.add         :root,              [],                    :read_only,  Interfaces::Navigation
       router.add         :unresolved_needs,  ["unresolved_needs"],  :parent,     Interfaces::UnresolvedNeedsList
       router.add_traced  :need,              ["needs",'*'],         :leaf,       Interfaces::Need
@@ -25,77 +21,93 @@ module FileManagementExample
         route.content_engine = RoadForest::ContentHandling.plaintext_engine
       end
     end
+  end
 
-    module Interfaces
-      class Navigation < RoadForest::Interface::RDF
-        def exists?
-          true
-        end
+  FileRecord = Struct.new(:name, :resolved)
 
-        def update(graph)
-          return false
-        end
+  module Interfaces
+    class Navigation < RoadForest::Interface::RDF
+      def exists?
+        true
+      end
 
-        def nav_entry(graph, name, path)
-          graph.add_node([:skos, :hasTopConcept], "#" + name) do |entry|
-            entry[:rdf, :type] = [:skos, "Concept"]
-            entry[:skos, :prefLabel] = name
-            entry[:foaf, "page"] = path
-          end
-        end
+      def update(graph)
+        return false
+      end
 
-        def fill_graph(graph)
-          graph[:rdf, "type"] = [:skos, "ConceptScheme"]
-          nav_entry(graph, "Unresolved", path_for(:unresolved_needs))
+      def nav_entry(graph, name, path)
+        graph.add_node([:skos, :hasTopConcept], "#" + name) do |entry|
+          entry[:rdf, :type] = [:skos, "Concept"]
+          entry[:skos, :prefLabel] = name
+          entry[:foaf, "page"] = path
         end
       end
 
-      class UnresolvedNeedsList < RoadForest::Interface::RDF
-        def exists?
-          true
-        end
+      def fill_graph(graph)
+        graph[:rdf, "type"] = [:skos, "ConceptScheme"]
+        nav_entry(graph, "Unresolved", url_for(:unresolved_needs))
+      end
+    end
 
-        def update(graph)
-        end
+    class UnresolvedNeedsList < RoadForest::Interface::RDF
+      def exists?
+        true
+      end
 
-        def add_child(graph)
-          services.logger.debug(graph.access_manager.source_graph.dump(:nquads))
-          new_file = FileRecord.new(graph.first(:lc, "name"), false)
-          services.file_records << new_file
-        end
+      def update(graph)
+      end
 
-        def fill_graph(graph)
+      def add_child(graph)
+        services.logger.debug(graph.access_manager.source_graph.dump(:nquads))
+        new_file = FileRecord.new(graph.first(:lc, "name"), false)
+        services.file_records << new_file
+      end
+
+      def fill_graph(graph)
+        unresolved = services.file_records.select do |record|
+          !record.resolved
+        end
+        if unresolved.empty?
+          graph.add_list(:lc, "needs")
+        else
           graph.add_list(:lc, "needs") do |list|
-            services.file_records.each do |record|
-              if !record.resolved
-                need = copy_interface(graph, :need, '*' => [record.name])
-                need[:lc, :name]
-                need[:lc, :digest]
-
-                list.append(need.subject)
-              end
+            unresolved.each do |record|
+              need = copy_interface(graph, :need, '*' => [record.name])
+              need[:lc, :name]
+              need[:lc, :digest]
+
+              list.append(need.subject)
             end
           end
         end
       end
+    end
 
-      class Need < RoadForest::Interface::RDF
-        def data
-          @data = services.file_records.find do |record|
-            record.name == params.remainder
-          end
+    class Need < RoadForest::Interface::RDF
+      def data
+        @data ||= services.file_records.find do |record|
+          record.name == params.remainder
         end
+      end
 
-        def graph_update(graph)
-          data.resolved = graph[:lc, "resolved"]
-          new_graph
+      def update_payload
+        payload_focus do |payload|
+          payload.add_node([:path, "forward"]) do |resolved|
+            resolved[[:path, "predicate"]] = [:lc, "resolved"]
+            resolved[[:path, "type"]] = [:xsd, "boolean"]
+          end
         end
+      end
 
-        def fill_graph(graph)
-          graph[[:lc, "resolved"]] = data.resolved
-          graph[[:lc, "name"]] = data.name
-          graph[[:lc, "contents"]] = path_for(:file_content)
-        end
+      def graph_update(graph)
+        data.resolved = graph[:lc, "resolved"]
+        new_graph
+      end
+
+      def fill_graph(graph)
+        graph[[:lc, "resolved"]] = data.resolved
+        graph[[:lc, "name"]] = data.name
+        graph[[:lc, "contents"]] = url_for(:file_content)
       end
     end
   end

data/lib/roadforest/application.rb

@@ -13,33 +13,25 @@ require 'roadforest/authorization'
 
 module RoadForest
   class Application
-    include Graph::Normalization
-
-    def initialize(canonical_host, services = nil, configuration = nil, dispatcher = nil)
-      @canonical_host = normalize_resource(canonical_host)
+    def initialize(services, configuration = nil)
+      @services = services
       configuration ||= Webmachine::Configuration.default
-      dispatcher ||= Dispatcher.new(self)
       super(configuration, dispatcher)
-      self.services = services unless services.nil?
-
-      setup
     end
 
-    def setup
-    end
-
-    attr_accessor :services, :canonical_host, :default_content_engine
+    attr_reader :services
 
+    def dispatcher
+      services.dispatcher
+    end
     alias router dispatcher
 
-    #XXX Is this the right place for this?
-    def services=(service_host)
-      @services = service_host
-      service_host.application = self
+    def canonical_host
+      services.canonical_host
     end
 
     def default_content_engine
-      @default_content_engine || ContentHandling.rdf_engine
+      services.default_content_engine
     end
   end
 end

data/lib/roadforest/application/dispatcher.rb

@@ -1,31 +1,57 @@
 require 'webmachine'
 require 'roadforest/application/route-adapter'
+require 'roadforest/application/path-provider'
 require 'roadforest/resource'
 
 module RoadForest
   class Dispatcher < Webmachine::Dispatcher
-    def initialize(application)
+    def initialize(services)
       super(method(:create_resource))
-      @application = application
+      @services = services
       @route_names = {}
+      @route_mappings = []
       @trace_by_default = false
     end
-    attr_accessor :application, :trace_by_default
+    attr_accessor :services, :trace_by_default
 
     def route_for_name(name)
       @route_names.fetch(name)
     end
 
-    def default_content_engine
-      @application.default_content_engine
+    def mapped_route_for_name(from, name, params)
+      mapping = @route_mappings.find do |mapping|
+        mapping.matches?(from, name, params)
+      end
+
+      unless mapping.nil?
+        name = mapping.to_name
+      end
+
+      return route_for_name(name)
     end
 
-    def path_provider
-      @path_provider ||= PathProvider.new(self)
+    def find_route(*args)
+      if block_given?
+        @routes.find{|route| yield(route)}
+      else
+        super
+      end
+    end
+
+    def each_route(&block)
+      @routes.each(&block)
+    end
+
+    def each_name_and_route(&block)
+      @route_names.each_pair(&block)
+    end
+
+    def default_content_engine
+      @services.default_content_engine
     end
 
-    def services
-      @application.services
+    def path_provider(route_name)
+      PathProvider.new(route_name, self)
     end
 
     # Add a named route to the dispatcher - the 90% case is handled by passing
@@ -68,5 +94,46 @@ module RoadForest
       end
     end
     alias add_traced add_traced_route
+
+    def add_route_map(route_map)
+      @route_mappings << route_map
+    end
+
+    class RouteMap
+      class Configurator
+        def initialize(name, router)
+          @router = router
+          @map = RouteMap.new
+          @map.in_name = name
+        end
+
+        def from(name, params=nil)
+          @map.from_name = name
+          @map.from_params = [*params]
+          self
+        end
+
+        def to(name)
+          @map.to_name = name
+          @router.add_route_map(@map)
+          nil
+        end
+      end
+
+      def initialize
+      end
+      attr_accessor :in_name, :from_name, :from_params, :to_name
+
+      def matches?(in_name, name, params)
+        return false unless in_name == @in_name
+        return false unless name == @from_name
+        return false unless @from_params.all?{|name| params.has_key?(name)}
+        return true
+      end
+    end
+
+    def map_in(route_name)
+      RouteMap::Configurator.new(route_name, self)
+    end
   end
 end

data/lib/roadforest/application/parameters.rb

@@ -19,7 +19,15 @@ module RoadForest
 
       def fetch(field_name)
         return path_tokens if field_name == '*'
-        @path_info.fetch(field_name){ @query_params.fetch(field_name) }
+        @path_info.fetch(field_name) do
+          if @query_params.respond_to?(:fetch)
+            @query_params.fetch(field_name) do
+              @query_params.fetch(field_name.to_s)
+            end
+          else
+            raise KeyError, "No parameter: #{field_name}"
+          end
+        end
       end
 
       def slice(*fields)

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

@@ -1,9 +1,18 @@
 module RoadForest
   class PathProvider
-    def initialize(dispatcher)
+    def initialize(route_name, dispatcher)
+      @route_name = route_name
       @dispatcher = dispatcher
     end
 
+    def services
+      @dispatcher.services
+    end
+
+    def route_for_name(name, params=nil)
+      @dispatcher.mapped_route_for_name(@route_name, name, params)
+    end
+
     # Get the URL to the given resource, with optional variables to be used
     # for bindings in the path spec.
     # @param [Webmachine::Resource] resource the resource to link to
@@ -12,10 +21,28 @@ module RoadForest
     # @return [String] the URL
     def path_for(name, vars = nil)
       vars ||= {}
-      route = @dispatcher.route_for_name(name)
+      route = route_for_name(name)
       ::RDF::URI.parse(route.build_path(vars))
     end
 
+    def pattern_for(name, vals = nil, extra = nil)
+      vars ||= {}
+      route = route_for_name(name)
+      Addressable::URI.parse(services.canonical_host.to_s).join(route.build_pattern(vals, extra))
+    end
+
+    def find_route(&block)
+      @dispatcher.find_route(&block)
+    end
+
+    def each_name_and_route(&block)
+      @dispatcher.each_name_and_route(&block)
+    end
+
+    def url_for(route_name, params = nil)
+      ::RDF::URI.new(Addressable::URI.parse(services.canonical_host.to_s).join(path_for(route_name, params)))
+    end
+
     def request_for(name, vars = nil)
       url = path_for(name, vars) #full url?
 
@@ -23,7 +50,7 @@ module RoadForest
     end
 
     def interface_for(name, vars = nil)
-      route = @dispatcher.route_for_name(name)
+      route = route_for_name(name)
       params = route.build_params(vars)
       route.resource.build_interface(params)
     end

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

@@ -1,5 +1,5 @@
 module RoadForest
-  class Application
+  class Application #XXX Lotta classes in this one file
     #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
@@ -21,7 +21,15 @@ module RoadForest
       end
 
       def build_interface(params)
-        interface_builder.call(route_name, params, router, router.services)
+        interface_builder.call(route_name, params, router.path_provider(route_name), router.services)
+      end
+
+      def interface_class
+        if interface_builder.respond_to? :interface_class
+          interface_builder.interface_class
+        else
+          nil
+        end
       end
 
       def trace?
@@ -36,20 +44,82 @@ module RoadForest
     #Extension of Webmachine's Routes that allows for rendering url paths and
     #parameter lists.
     class Route < Webmachine::Dispatcher::Route
+      attr_accessor :name
       # 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|
+        vars = vars.to_hash
+        vars = vars.dup
+        path_spec = resolve_path_spec(vars)
+        if path_spec.any?{|segment| segment.is_a?(Symbol) or segment == "*"}
+          raise "Cannot build path - missing vars: #{path_spec.inspect}"
+        end
+        path = "/" + path_spec.join("/")
+        vars.delete('*')
+        unless vars.empty?
+          path += "?" + vars.map do |key,value|
+            [key,value].join("=")
+          end.join("&")
+        end
+        return path
+      end
+
+      def build_pattern(vals = nil, extra_vars = nil)
+        vals ||= {}
+        extra_vars ||= []
+        vals = vals.to_hash
+        vals = vals.dup
+        extra_vars -= path_spec.find_all{|segment| segment.is_a? Symbol}
+
+        pattern_spec = resolve_path_spec(vals)
+
+        pattern = pattern_spec.map do |segment|
+          case segment
+          when '*'
+            "{/rest*}"
+          when Symbol
+            "{/#{segment}}"
+          else
+            "/" + segment
+          end
+        end.join("")
+
+        vals.delete('*')
+        unless vals.empty?
+          pattern += "?" + vals.map do |key,value|
+            [key,value].join("=")
+          end.join("&")
+        end
+        unless extra_vars.empty?
+          pattern += "{?#{extra_vars.join(",")}}"
+        end
+        return pattern
+      end
+
+      def resolve_path_spec(vars)
+        path_spec.map do |segment|
           case segment
           when '*',Symbol
-            vars.fetch(segment)
+            if (string = vars.delete(segment)).nil?
+              segment
+            else
+              string
+            end
           when String
             segment
           end
-        end.join("/")
+        end
+      end
+
+      def interface_class
+        if resource.respond_to? :interface_class
+          resource.interface_class
+        else
+          nil
+        end
       end
 
       def build_params(vars = nil)
@@ -69,13 +139,24 @@ module RoadForest
       end
     end
 
+    class InterfaceBuilder
+      attr_reader :interface_class
+      def initialize(interface_class)
+        @interface_class = interface_class
+      end
+
+      def call(name, params, router, services)
+        interface_class.new(name, params, router, services)
+      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
+      attr_accessor :resource_type, :interface_builder, :interface_class, :services, :trace, :content_engine
 
       def resource_builder
         @resource_builder ||= proc do |request, response|
@@ -88,9 +169,7 @@ module RoadForest
       end
 
       def interface_builder
-        @interface_builder ||= proc do |name, params, router, services|
-          interface_class.new(name, params, router.path_provider, services)
-        end
+        @interface_builder ||= InterfaceBuilder.new(interface_class)
       end
 
       def build_interface(&block)
@@ -100,11 +179,14 @@ module RoadForest
       def route
         @route ||=
           begin
-            if guard.nil?
-              Route.new(path_spec, resource_adapter, bindings || {})
-            else
-              Route.new(path_spec, resource_adapter, bindings || {}, &guard)
-            end
+            route =
+              if guard.nil?
+                Route.new(path_spec, resource_adapter, bindings || {})
+              else
+                Route.new(path_spec, resource_adapter, bindings || {}, &guard)
+              end
+            route.name = route_name
+            route
           end
       end