roadforest 0.0.3 → 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f4089bbfd4e58f956b5088ab646d62d904f11120
+  data.tar.gz: ebbccc85db766f417254b23aee95d022392e1b58
+SHA512:
+  metadata.gz: ecbf4fd992414ab2b73de911097455ef4712fbb9cb0c6f7bd7316a62abad9ca7b12ea5415b33817aaf9fc3bf83731500e684fe1099fa9ac217247ce94fe66883
+  data.tar.gz: 0a4125f562e7c390e5a515e4e06ba9099bd50268fa596734de825bce26c038d85c612594bc2b4db5ec521506430db1797e4ba3d3e772604f71de3c2a314d0c07

data/examples/file-management.rb

@@ -36,7 +36,7 @@ module FileManagementExample
         def nav_entry(graph, name, path)
           graph.add_node([:skos, :hasTopConcept], "#" + name) do |entry|
             entry[:rdf, :type] = [:skos, "Concept"]
-            entry[:skos, :label] = name
+            entry[:skos, :prefLabel] = name
             entry[:foaf, "page"] = path
           end
         end
@@ -65,13 +65,11 @@ module FileManagementExample
           graph.add_list(:lc, "needs") do |list|
             services.file_records.each do |record|
               if !record.resolved
-#                need = copy_from(:need, '*' => record.name)
-#                list.add_node(need.url) do |node|
-#                  need.target = node
-#                  need[:lc, :name]
-#                  need[:lc, :digest]
-#                end
-                list << path_for(:need, '*' => record.name)
+                need = copy_model(graph, :need, '*' => [record.name])
+                need[:lc, :name]
+                need[:lc, :digest]
+
+                list.append(need.subject)
               end
             end
           end
@@ -79,7 +77,7 @@ module FileManagementExample
       end
 
       class NeedContent < RoadForest::BlobModel
-        add_type "text/plain", TypeHandlers::Handler.new
+        add_type TypeHandlers::Handler.new, "text/plain"
       end
 
       class Need < RoadForest::RDFModel

data/lib/roadforest/application/dispatcher.rb

@@ -3,39 +3,16 @@ require 'roadforest/application/route-adapter'
 
 module RoadForest
   class Dispatcher < Webmachine::Dispatcher
-    def initialize(services)
+    def initialize(application)
       super(method(:create_resource))
-      @services = services
+      @application = application
       @route_names = {}
       @trace_by_default = false
     end
-    attr_accessor :services, :trace_by_default
+    attr_accessor :application, :trace_by_default
 
-    def bundle(resource_class, &block)
-      Application::RouteAdapter.new(resource_class, &block)
-    end
-
-    def bundle_typed_resource(resource_type, model_class, route_name)
-      resource_class = Resource.get(resource_type)
-      bundle(resource_class) do |resource, request, response|
-        resource.model = model_class.new(route_name, resource.params, services)
-      end
-    end
-
-    def bundle_traced_resource(resource_type, model_class, route_name)
-      resource_class = Resource.get(resource_type)
-      bundle(resource_class) do |resource, request, response|
-        resource.model = model_class.new(route_name, resource.params, services)
-        resource.trace = true
-      end
-    end
-
-    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
+    def route_for_name(name)
+      @route_names.fetch(name)
     end
 
     def add_route(name, path_spec, resource_type, model_class, bindings = nil, &block)
@@ -59,8 +36,27 @@ module RoadForest
     end
     alias add_traced add_traced_route
 
-    def route_for_name(name)
-      @route_names.fetch(name)
+    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
+
+    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
+
+    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
     end
 
     class Route < Webmachine::Dispatcher::Route
@@ -68,7 +64,8 @@ module RoadForest
       # substitution.
       # @param [Hash] vars values for the path variables
       # @return [String] the valid URL for the route
-      def build_path(vars = {})
+      def build_path(vars = nil)
+        vars ||= {}
         "/" + path_spec.map do |segment|
           case segment
           when '*',Symbol
@@ -78,6 +75,22 @@ module RoadForest
           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
   end
 end

data/lib/roadforest/application/parameters.rb

@@ -12,13 +12,14 @@ module RoadForest
       attr_accessor :path_info, :query_params, :path_tokens
 
       def [](field_name)
-        return path_tokens if field_Name == '*'
-        @path_info[field_name] || @query_params[field_name]
+        fetch(field_name)
+      rescue KeyError
+        nil
       end
 
       def fetch(field_name)
-        return path_tokens if field_Name == '*'
-        @path_info[field_name] || @query_params.fetch(field_name)
+        return path_tokens if field_name == '*'
+        @path_info.fetch(field_name){ @query_params.fetch(field_name) }
       end
 
       def slice(*fields)

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

@@ -10,9 +10,22 @@ module RoadForest
     # @param [Hash] vars the values for the required path variables
     # @raise [RuntimeError] Raised if the resource is not routable.
     # @return [String] the URL
-    def path_for(name, vars = {})
+    def path_for(name, vars = nil)
+      vars ||= {}
       route = @dispatcher.route_for_name(name)
       ::RDF::URI.parse(route.build_path(vars))
     end
+
+    def request_for(name, vars = nil)
+      url = path_for(name, vars) #full url?
+
+      Webmachine::Request.new(method, url, headers, body)
+    end
+
+    def model_for(name, vars = nil)
+      route = @dispatcher.route_for_name(name)
+      params = route.build_params(vars)
+      route.resource.build_model(params)
+    end
   end
 end

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

@@ -1,17 +1,28 @@
 module RoadForest
   class Application
     class RouteAdapter
-      def initialize(resource_class, &setup_block)
+      def initialize(route_name, resource_class, model_class)
         @resource_class = resource_class
-        @setup_block = setup_block
+
+        @route_name = route_name
+        @model_class = model_class
+        @application = nil
+        @trace = false
+        yield self if block_given?
       end
+      attr_accessor :route_name, :resource_class, :model_class, :application, :trace
 
       def new(request, response)
-        resource = @resource_class.new(request, response)
-        @setup_block[resource, request, response]
+        resource = resource_class.new(request, response)
+        resource.model = build_model(resource.params)
+        resource.trace = trace
         resource
       end
 
+      def build_model(params)
+        model_class.new(route_name, params, application.services)
+      end
+
       def <(klass)
         if klass <= Webmachine::Resource
           return true

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

@@ -1,10 +1,44 @@
-class RoadForest::Application
-  #XXX Worth doing some meta to get sanity checking of configs here? Better
-  #fail early if there's no DB configured, right?
-  class ServicesHost
-    def initialize
-    end
+module RoadForest
+  class Application
+    #XXX Worth doing some meta to get reality checking of configs here? Better
+    #fail early if there's no DB configured, right?
+    class ServicesHost
+      def initialize
+      end
+
+      attr_writer :application
+      attr_writer :router, :canonical_host, :type_handling
+      attr_writer :logger, :authorization
+
+      def canonical_host
+        @application.canonical_host
+      end
+
+      def router
+        @router ||= PathProvider.new(@application.dispatcher)
+      end
 
-    attr_accessor :router, :canonical_host, :type_handling, :logger
+      def authorization
+        @authorization ||=
+          begin
+            require 'roadforest/authorization'
+            Authorization::Manager.new
+          end
+      end
+
+      def type_handling
+        @type_handling ||= ContentHandling::Engine.default
+      end
+
+      def logger
+        @logger ||=
+          begin
+            require 'logger'
+            Logger.new("roadforest.log")
+          end
+      end
+
+      alias authz authorization
+    end
   end
 end

data/lib/roadforest/application.rb

@@ -9,6 +9,7 @@ require 'roadforest/application/services-host'
 require 'roadforest/resource/rdf'
 require 'roadforest/content-handling/engine'
 require 'roadforest/rdf/normalization'
+require 'roadforest/authorization'
 
 module RoadForest
   class Application
@@ -17,7 +18,7 @@ module RoadForest
     def initialize(canonical_host, services = nil, configuration = nil, dispatcher = nil)
       @canonical_host = normalize_resource(canonical_host)
       configuration ||= Webmachine::Configuration.default
-      dispatcher ||= Dispatcher.new(services)
+      dispatcher ||= Dispatcher.new(self)
       super(configuration, dispatcher)
       self.services = services unless services.nil?
 
@@ -31,17 +32,12 @@ module RoadForest
 
     alias router dispatcher
 
+    #XXX Is this the right place for this?
     def services=(service_host)
-      router.services = service_host
       @services = service_host
+      service_host.application = self
       @services.canonical_host = canonical_host
       @services.router = PathProvider.new(@dispatcher)
-      @services.type_handling ||= ContentHandling::Engine.default
-      @services.logger ||=
-        begin
-          require 'logger'
-          Logger.new("roadforest.log")
-        end
     end
   end
 end

data/lib/roadforest/authorization.rb

@@ -0,0 +1,231 @@
+require 'base64'
+require 'openssl'
+require 'roadforest'
+require 'roadforest/utility/class-registry'
+
+module RoadForest
+  module Authorization
+    class GrantBuilder
+      def initialize(salt, cache)
+        @salt = salt
+        @cache = cache
+        @list = []
+      end
+      attr_reader :list
+
+      def add(name, params=nil)
+        canonical =
+          if params.nil?
+            [@salt, name]
+          else
+            [@salt, name, params.keys.sort.map do |key|
+              [key, params[key]]
+            end]
+          end
+        @list << @cache[canonical]
+      end
+    end
+
+    class GrantsHolder
+      def initialize(salt, hash_function)
+        @salt = salt
+
+        digester = OpenSSL::Digest.new(hash_function)
+        @grants_cache = Hash.new do |h, k| #XXX potential resource exhaustion here - only accumulate auth'd results
+          digester.reset
+          h[k] = digester.digest(h.inspect)
+        end
+      end
+
+      def get(key)
+        @grants_cache[key]
+      end
+      alias [] get
+
+      def build_grants
+        builder = GrantBuilder.new(@salt, self)
+        yield builder
+        return builder.list
+      end
+    end
+
+    class Manager
+      attr_accessor :authenticator
+      attr_accessor :policy
+      attr_reader :grants
+
+      HASH_FUNCTION = "SHA256".freeze
+
+      def initialize(salt = nil, authenticator = nil, policy = nil)
+        @grants = GrantsHolder.new(salt || "roadforest-insecure", HASH_FUNCTION)
+
+        @authenticator = authenticator || AuthenticationChain.new(DefaultAuthenticationStore.new)
+        @policy = policy || AuthorizationPolicy.new
+        @policy.grants_holder = @grants
+      end
+
+      def build_grants(&block)
+        @grants.build_grants(&block)
+      end
+
+      def challenge(options)
+        @authenticator.challenge(options)
+      end
+
+      # @returns [:public|:granted|:refused]
+      #
+      # :public means the request doesn't need authorization
+      # :granted means that it does need authz but the credentials passed are
+      #   allowed to access the resource
+      # :refused means that the credentials passed are not allowed to access
+      #   the resource
+      #
+      # TODO: Resource needs to add s-maxage=0 for :granted requests or public
+      # for :public requests to the CacheControl header
+      def authorization(header, required_grants)
+        entity = authenticator.authenticate(header)
+
+        return :refused if entity.nil?
+
+        available_grants = policy.grants_for(entity)
+
+        if required_grants.any?{|required| available_grants.include?(required)}
+          return :granted
+        else
+          return :refused
+        end
+      end
+    end
+
+    class AuthenticationChain
+      class Scheme
+        def self.registry_purpose; "authentication scheme"; end
+        extend Utility::ClassRegistry::Registrar
+
+        def self.register(name)
+          registrar.registry.add(name, self.new)
+        end
+
+        def authenticated_entity(credentials, store)
+          nil
+        end
+      end
+
+      class Basic < Scheme
+        register "Basic"
+
+        def challenge(options)
+          "Basic realm=\"#{options.fetch(:realm, "Roadforest App")}\""
+        end
+
+        def authenticated_entity(credentials, store)
+          username, password = Base64.decode64(credentials).split(':',2)
+
+          entity = store.by_username(username)
+          entity.authenticate_by_password(password)
+          entity
+        end
+      end
+
+      def initialize(store)
+        @store = store
+      end
+      attr_reader :store
+
+      def handler_for(scheme)
+        Scheme.get(scheme)
+      rescue
+        nil
+      end
+
+      def challenge(options)
+        (Scheme.registry.names.map do |scheme_name|
+          handler_for(scheme_name).challenge(options)
+        end).join(", ")
+      end
+
+      def add_account(user,password,token)
+        @store.add_account(user,password,token)
+      end
+
+      def authenticate(header)
+        return nil if header.nil?
+        scheme, credentials = header.split(/\s+/, 2)
+
+        handler = handler_for(scheme)
+        return nil if handler.nil?
+
+        entity = handler.authenticated_entity(credentials, store)
+        return nil if entity.nil?
+        return nil unless entity.authenticated?
+        return entity
+      end
+    end
+
+    class AuthEntity
+      def initialize
+        @authenticated = false
+      end
+      attr_accessor :username, :password, :token
+
+      def authenticated?
+        !!@authenticated
+      end
+
+      def authenticate_by_password(password)
+        @authenticated = (!password.nil? and password == @password)
+      end
+
+      def authenticate_by_token(token)
+        @authenticated = (!token.nil? and token == @token)
+      end
+
+      def authenticate!
+        @authenticated = true
+      end
+    end
+
+    class DefaultAuthenticationStore
+      def initialize
+        @accounts = []
+      end
+
+      def build_entity(account)
+        return nil if account.nil?
+        AuthEntity.new.tap do |entity|
+          entity.username = account[0]
+          entity.password = account[1]
+          entity.token = account[2]
+        end
+      end
+
+      def add_account(user, password, token)
+        @accounts << [user, password, token]
+      end
+
+      def by_username(username)
+        account = @accounts.find{|account| account[0] == username }
+        build_entity(account)
+      end
+
+      def by_token(token)
+        account = @accounts.find{|account| account[2] == token }
+        build_entity(account)
+      end
+    end
+
+    class AuthorizationPolicy
+      attr_accessor :grants_holder
+
+      def build_grants(&block)
+        grants_holder.build_grants(&block)
+      end
+
+      def grants_for(entity)
+        build_grants do |builder|
+          builder.add(:admin)
+        end
+      end
+    end
+  end
+end

data/lib/roadforest/blob-model.rb

@@ -9,19 +9,10 @@ module RoadForest
         @engine ||= ContentHandling::Engine.new
       end
 
-      def add_type(type, handler)
-        add_parser(type, handler)
-        add_renderer(type, handler)
+      def add_type(handler, type)
+        type_handling.add_type(handler, type)
       end
       alias add add_type
-
-      def add_parser(type, handler)
-        type_handling.add_parser(type, handler)
-      end
-
-      def add_renderer(type, handler)
-        type_handling.add_renderer(type, handler)
-      end
     end
 
     def type_handling

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

@@ -1,4 +1,5 @@
 require 'roadforest/content-handling/media-type'
+require 'roadforest/content-handling/handler-wrap'
 
 module RoadForest
   module ContentHandling
@@ -47,8 +48,13 @@ module RoadForest
 
       def self.default
         require 'roadforest/content-handling/type-handlers/jsonld'
+        require 'roadforest/content-handling/type-handlers/rdfa'
         self.new.tap do |engine|
-          engine.add "application/ld+json", RoadForest::MediaType::Handlers::JSONLD.new
+          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
 
@@ -59,21 +65,21 @@ module RoadForest
       end
       attr_reader :renderers, :parsers
 
-      def add_type(type, handler)
+      def add_type(handler, type)
         type = MediaType.parse(type)
-        add_parser(type, handler)
-        add_renderer(type, handler)
+        add_parser(handler, type)
+        add_renderer(handler, type)
       end
       alias add add_type
 
-      def add_parser(type, object)
+      def add_parser(object, type)
         type = MediaType.parse(type)
         wrapper = RoadForest::MediaType::Handlers::Wrap::Parse.new(type, object)
         parsers.add(wrapper)
       end
       alias accept add_parser
 
-      def add_renderer(type, object)
+      def add_renderer(object, type)
         type = MediaType.parse(type)
         wrapper = RoadForest::MediaType::Handlers::Wrap::Render.new(type, object)
         renderers.add(wrapper)

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

@@ -0,0 +1,45 @@
+module RoadForest
+  module MediaType
+    module Handlers
+      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 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
+
+          def content_type_header
+            @type.content_type_header
+          end
+        end
+
+        class Parse < Wrapper
+          def call(resource)
+            @handler.parse_for(resource)
+          end
+
+          def add_child(resource)
+            @handler.add_child_to(resource)
+          end
+        end
+      end
+    end
+  end
+end