roadforest 0.0.1

data/lib/roadforest/resource/http/form-parsing.rb

@@ -0,0 +1,81 @@
+=begin
+I think this code might be useful soon
+module RoadForest
+  module ResourceMixin
+    module FormParsing
+      def self.content_types_accepted
+        [
+          ["application/x-www-form-urlencoded", :handle_url_encoded_form],
+          ["multipart/form-data", :handle_multipart_form]
+        ]
+      end
+
+      def process_post
+        content_type = Webmachine::MediaType.parse(request.content_type)
+        if content_type.match?("application/x-www-form-urlencoded")
+          handle_url_encoded_form
+        elsif content_type.match?("multipart/form-data")
+          handle_multipart_form
+        else
+          false
+        end
+      end
+
+      def parse_url_encoded_form
+        Hash[URI::decode_www_form(request.body)]
+      end
+
+      def parse_multipart_form
+        form_data = {}
+        reader = multipart_reader(request.content_type, form_data)
+
+        request.body.each do |chunk|
+          reader.write(chunk)
+        end
+
+        return form_data
+      end
+
+      def multipart_reader(content_type, form_data)
+        content_type = Webmachine::MediaType.parse(content_type)
+        reader = MultipartParser::Reader.new(content_type.params["boundary"])
+        reader.on_error do |message|
+          raise message
+        end
+
+        reader.on_part do |part|
+          case part.mime
+          when nil
+            form_data[part.name] = ""
+            part.on_data do |data|
+              form_data[part.name] << data
+            end
+          else
+            temp_file = Tempfile.new(part.filename)
+
+            form_data[part.name] = [part, temp_file]
+
+            part.on_data do |data|
+              temp_file.write(data)
+            end
+
+            part.on_end do
+              temp_file.close
+            end
+          end
+        end
+
+        return reader
+      end
+
+      def handle_url_encoded_form
+        handle_form(parse_url_encoded_form)
+      end
+
+      def handle_multipart_form
+        handle_form(parse_multipart_form)
+      end
+    end
+  end
+end
+=end

data/lib/roadforest/resource/rdf/leaf-item.rb

@@ -0,0 +1,21 @@
+require 'roadforest/resource/rdf/read-only'
+require 'roadforest/resource/role/writable'
+
+module RoadForest
+  module Resource
+    module RDF
+    #Used for a simple resource that has properties that can be updated, but
+    #doesn't have any children - for example a comment
+    class LeafItem < ReadOnly
+      register :leaf
+
+      include Role::Writable
+
+      def allowed_methods
+        super + Role::Writable.allowed_methods
+      end
+    end
+
+    end
+  end
+end

data/lib/roadforest/resource/rdf/list.rb

@@ -0,0 +1,19 @@
+require 'roadforest/resource/rdf/read-only'
+require 'roadforest/resource/role/has-children'
+module RoadForest
+  module Resource
+    module RDF
+      #Used for a resource that simply represents a list of other resources
+      #without having any properties itself - a list of posts, for instance
+      class List < ReadOnly
+        register :list
+
+        include Role::HasChildren
+
+        def allowed_methods
+          super + Role::HasChildren.allowed_methods
+        end
+      end
+    end
+  end
+end

data/lib/roadforest/resource/rdf/parent-item.rb

@@ -0,0 +1,26 @@
+require 'roadforest/resource/rdf/read-only'
+require 'roadforest/resource/role/writable'
+require 'roadforest/resource/role/has-children'
+module RoadForest
+  module Resource
+    module RDF
+    #Used for a resource that has properties itself that can be updated, and
+    #also has one or more kinds of dependent or subordinate resources - can new
+    #resources be created by posting to this one? e.g. a post, which can have
+    #comments
+    class ParentItem < ReadOnly
+      register :parent
+
+      include Role::Writable
+      include Role::HasChildren
+
+      def allowed_methods
+        (super + [Role::Writable, Role::HasChildren].inject([]) do |list, mod|
+          list + mod.allowed_methods
+        end).uniq
+      end
+    end
+
+    end
+  end
+end

data/lib/roadforest/resource/rdf/read-only.rb

@@ -0,0 +1,100 @@
+require 'roadforest/resource/handlers'
+require 'roadforest/application/parameters'
+
+module RoadForest
+  module Resource
+    module RDF
+      #Used for a resource that presents a read-only representation
+      class ReadOnly < Webmachine::Resource
+        def self.register(method_name)
+          Handlers.register(method_name, self)
+        end
+
+        register :read_only
+
+        attr_accessor :model, :trace
+
+        ### RoadForest interface
+
+        def params
+          params = Application::Parameters.new do |params|
+            params.path_info = @request.path_info
+            params.query_params = @request.query_params
+            params.path_tokens = @request.path_tokens
+          end
+        end
+
+        def request_accept_header
+          request.headers["Accept"] || "*/*"
+        end
+
+        def response_content_type=(type)
+          response.headers["Content-Type"] = type
+        end
+
+        def response_body=(body)
+          response.body = body
+        end
+
+        def retrieve_model
+          absolutize(@model.canonical_host, @model.retrieve)
+        end
+        alias retreive_model retrieve_model
+
+        #      def known_methods
+        #        super + ["PATCH"]
+        #      end
+
+        def model_supports(action)
+          @model.respond_to?(action)
+        end
+        ### Webmachine interface
+
+        def trace?
+          !!@trace
+        end
+
+        #Overridden rather than metaprogram content type methods
+        def send(*args)
+          if args.length == 1 and not model.nil?
+            model.type_handling.fetch(args.first).call(self)
+          else
+            super
+          end
+        rescue KeyError
+          super
+        end
+
+        def method(name)
+          if model.nil?
+            super
+          else
+            model.type_handling.fetch(name).method(:call)
+          end
+        rescue KeyError
+          super
+        end
+
+        def content_types_provided
+          model.type_handling.renderers.type_map
+        end
+
+        def resource_exists?
+          @model.exists?
+        end
+
+        def generate_etag
+          @model.etag
+        end
+
+        def last_modified
+          @model.last_modified
+        end
+
+        def expires
+          @model.expires
+        end
+      end
+    end
+  end
+end

data/lib/roadforest/resource/rdf.rb

@@ -0,0 +1,4 @@
+require 'roadforest/resource/rdf/leaf-item'
+require 'roadforest/resource/rdf/parent-item'
+require 'roadforest/resource/rdf/list'
+require 'roadforest/resource/rdf/read-only'

data/lib/roadforest/resource/role/has-children.rb

@@ -0,0 +1,22 @@
+module RoadForest
+  module Resource
+    module Role
+      module HasChildren
+        def self.allowed_methods
+          %w[POST]
+        end
+
+        def post_is_create
+          false
+        end
+
+        def process_post
+          parser = model.type_handling.choose_parser(request.content_type || 'application/octet-stream')
+
+          parser.add_child(self)
+          return true
+        end
+      end
+    end
+  end
+end

data/lib/roadforest/resource/role/writable.rb

@@ -0,0 +1,43 @@
+require 'roadforest/resource/role/has-children'
+
+module RoadForest
+  module Resource
+    module Role
+      module Writable
+        class IncludeOrder < StandardError; end
+
+        def self.allowed_methods
+          %w[POST PUT DELETE]
+        end
+
+        def self.included(mod)
+          if mod.ancestors.include?(HasChildren)
+            #Might regret this later - some kind of "I promise to fix it?"
+            raise IncludeOrder, "Writable has to be included before HasChildren"
+          end
+        end
+
+        def post_is_create
+          true
+        end
+
+        def content_types_accepted
+          model.type_handling.parsers.type_map
+        end
+
+        def request_body
+          @request.body
+        end
+
+        def known_content_type(content_type)
+          content_type = Webmachine::MediaType.parse(content_type)
+          content_types_accepted.any?{|ct, _| content_type.match?(ct)}
+        end
+
+        def delete_resource
+          @model.delete(params)
+        end
+      end
+    end
+  end
+end

data/lib/roadforest/server.rb

@@ -0,0 +1,3 @@
+#This file is intended as the single entry point for RoadForest server code
+require 'roadforest/application'
+require 'roadforest/models'

data/lib/roadforest/test-support/dispatcher-facade.rb

@@ -0,0 +1,77 @@
+require 'roadforest/test-support/trace-formatter'
+require 'webmachine/headers'
+require 'webmachine/request'
+require 'webmachine/response'
+require 'webmachine/decision/flow'
+module RoadForest
+  module TestSupport
+    class DispatcherFacade < BasicObject
+      def initialize(dispatcher)
+        @dispatcher = dispatcher
+      end
+
+      def method_missing(method, *args, &block)
+        @dispatcher.__send__(method, *args, &block)
+      end
+
+      def dispatch(request, response)
+        if resource = @dispatcher.find_resource(request, response)
+          FSM.new(resource, request, response).run
+        else
+          Webmachine.render_error(404, request, response)
+        end
+      end
+    end
+
+    class FSM < ::Webmachine::Decision::FSM
+      def self.trace_on
+        unless ancestors.include? Webmachine::Trace::FSM
+          include Webmachine::Trace::FSM
+        end
+        Webmachine::Trace.trace_store = :memory
+      end
+
+      def self.dump_trace
+        puts trace_dump
+      end
+
+      def self.trace_dump
+        Webmachine::Trace.traces.map do |trace|
+          TraceFormatter.new(Webmachine::Trace.fetch(trace))
+        end.join("\n")
+      end
+
+      #Um, actually *don't* handle exceptions
+      def handle_exceptions
+        yield.tap do |result|
+          #p result #ok
+        end
+      end
+
+      def initialize_tracing
+        return if self.class.ancestors.include? Webmachine::Trace::FSM
+        super
+      end
+
+      def run
+        state = Webmachine::Decision::Flow::START
+        trace_request(request)
+        loop do
+          trace_decision(state)
+          result = handle_exceptions { send(state) }
+          case result
+          when Fixnum # Response code
+            respond(result)
+            break
+          when Symbol # Next state
+            state = result
+          else # You bwoke it
+            raise InvalidResource, t('fsm_broke', :state => state, :result => result.inspect)
+          end
+        end
+      ensure
+        trace_response(response)
+      end
+    end
+  end
+end

data/lib/roadforest/test-support/http-client.rb

@@ -0,0 +1,151 @@
+require 'addressable/uri'
+require 'roadforest/test-support/dispatcher-facade'
+module RoadForest
+  module TestSupport
+    class HTTPClient
+      def initialize(app, url)
+        @app = app
+        @default_url = Addressable::URI.parse(url)
+        @exchanges = []
+        @dispatcher = DispatcherFacade.new(@app.dispatcher)
+      end
+      attr_reader :exchanges
+
+      def inspect
+        "#<#{self.class.name}:#{"%0xd" % object_id} #{exchanges.length} exchanges>"
+      end
+
+      def do_request(request)
+        uri = request.url
+
+        uri = Addressable::URI.parse(uri)
+        uri = @default_url.join(uri)
+
+        exchange = Exchange.new
+
+        exchange.method = request.method
+        exchange.uri = uri
+        exchange.body = request.body
+        exchange.dispatcher = @dispatcher
+
+        @exchanges << exchange
+
+        exchange.header('Host', [uri.host, uri.port].compact.join(':'))
+        exchange.header('Accept', '*/*')
+        request.headers.each do |name, value|
+          exchange.header(name, value)
+        end
+
+        yield exchange if block_given?
+
+        #puts; puts "#{__FILE__}:#{__LINE__} => #{(request).inspect}"
+
+        exchange.do_request
+
+        response = HTTP::Response.new
+        response.headers = exchange.response.headers.dup
+        response.status = exchange.response.code
+        response.body_string = exchange.response.body
+
+        #puts; puts "#{__FILE__}:#{__LINE__} => #{(response).inspect}"
+        return response
+      end
+
+      class Exchange
+        def initialize
+          @uri = nil
+          @method = nil
+          @headers = Webmachine::Headers.new
+          @query_params = {}
+          @req = nil
+          @res = nil
+        end
+        attr_accessor :uri, :method, :body, :dispatcher
+        attr_reader :headers, :query_params
+
+        # Returns the request object.
+        def request
+          @req || webmachine_test_error('No request object yet. Issue a request first.')
+        end
+
+        # Returns the response object after a request has been made.
+        def response
+          @res || webmachine_test_error('No response yet. Issue a request first!')
+        end
+
+        # Set a single header for the next request.
+        def header(name, value)
+          @headers[name] = value
+        end
+
+        def headers=(hash)
+          hash.each do |key, value|
+            header(key, value)
+          end
+        end
+
+        def query_param(name, value)
+          @query_params[name] = value
+        end
+
+        def query_params=(hash)
+          hash.each do |key, value|
+            query_param(key, value)
+          end
+        end
+
+        def do_request
+          self.uri = Addressable::URI.parse(uri)
+          uri.query_values = (uri.query_values || {}).merge(query_params)
+
+
+          @req = Webmachine::Request.new(method, uri, headers, RequestBody.new(body))
+          @res = Webmachine::Response.new
+
+          dispatcher.dispatch(@req, @res)
+
+          return @res
+        end
+
+        class RequestBody
+          # @return the request from Mongrel
+
+          # @param request the request from Mongrel
+          def initialize(body)
+            @raw_body = body
+          end
+
+          def body
+            @body =
+              case @raw_body
+              when IO, StringIO
+                @raw_body.rewind
+                @raw_body.read
+              when String
+                @raw_body
+              else
+                raise "Can't handle body type: #{@raw_body.class}"
+              end
+
+          end
+
+          # @return [String] the request body as a string
+          def to_s
+            body
+          end
+
+          # @yield [chunk]
+          # @yieldparam [String] chunk a chunk of the request body
+          def each(&block)
+            yield(body)
+          end
+        end # class RequestBody
+
+        private
+        def webmachine_test_error(msg)
+          raise Webmachine::Test::Error.new(msg)
+        end
+      end
+    end
+  end
+end

data/lib/roadforest/test-support/matchers.rb

@@ -0,0 +1,67 @@
+module RoadForest
+  module Testing
+    class MatchesQuery
+      def initialize(&block)
+        @query = ::RDF::Query.new(&block)
+      end
+
+      def matches?(actual)
+        @actual = actual
+        solutions = @query.execute(actual)
+        not solutions.empty?
+      end
+
+      def failure_message_for_should
+        "expected #{@query.inspect} to return solutions on #{@actual.inspect}, but didn't"
+      end
+    end
+
+    class ListEquivalence
+      def initialize(expected)
+        @expected = expected
+      end
+
+      def matches?(actual)
+        @actual = actual
+        @actual_extra = @actual - @expected
+        @expected_extra = @expected - @actual
+        @actual_extra.empty? and @expected_extra.empty?
+      end
+
+      def failure_message_for_should
+        "expected #{@actual.inspect} to have the same elements as #{@expected.inspect}"
+      end
+    end
+
+    class StatementsFromGraph
+      def initialize(graph)
+        @graph = graph
+      end
+
+      def that_match_query(query)
+        @graph.query(query).to_a
+      end
+    end
+
+    module HelperMethods
+      def statements_from_graph(graph)
+        StatementsFromGraph.new(graph)
+      end
+    end
+
+    module MatcherMethods
+      def match_query(&block)
+        MatchesQuery.new(&block)
+      end
+
+      def be_equivalent_to(list)
+        ListEquivalence.new(list)
+      end
+    end
+  end
+end
+
+RSpec::configure do |config|
+  config.include RoadForest::Testing::MatcherMethods
+  config.include RoadForest::Testing::HelperMethods
+end

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

@@ -0,0 +1,23 @@
+require 'roadforest/rdf/graph-store'
+require 'roadforest/remote-host'
+require 'roadforest/test-support/http-client'
+module RoadForest::TestSupport
+  class RemoteHost < ::RoadForest::RemoteHost
+    def initialize(app)
+      @app = app
+      super(app.canonical_host)
+    end
+
+    def build_graph_store
+      RoadForest::RDF::GraphStore.new
+    end
+
+    def http_client
+      @http_client ||= HTTPClient.new(@app, @url)
+    end
+
+    def http_exchanges
+      http_client.exchanges
+    end
+  end
+end