roadforest 0.1 → 0.5

data/lib/roadforest/model.rb

@@ -1,209 +0,0 @@
-require 'roadforest/rdf/graph-store'
-require 'roadforest/rdf/etagging'
-require 'roadforest/rdf/access-manager'
-require 'roadforest/rdf/graph-focus'
-
-module RoadForest
-  class ProcessingSequenceError < StandardError
-  end
-
-  class Model
-    def initialize(route_name, params, services)
-      @route_name = route_name
-      @params = params
-      @services = services
-      @data = nil
-      @response_values = {}
-    end
-    attr_reader :route_name, :params, :services, :data
-    attr_reader :response_values
-
-    def path_for(route_name = nil, params = nil)
-      services.router.path_for(route_name, params || self.params)
-    end
-
-    def url_for(route_name, params = nil)
-      Addressable::URI.parse(canonical_host.to_s).join(path_for(route_name, params))
-    end
-
-    def model_for(route_name = nil, params = nil)
-      services.router.model_for(route_name, params || self.params)
-    end
-
-    def required_grants(method)
-      services.authz.build_grants do |grants|
-        grants.add(:admin)
-      end
-    end
-
-    def authorization(method, header)
-      required = required_grants(method)
-      if required.empty?
-        :public
-      else
-        services.authz.authorization(header, required_grants(method))
-      end
-    end
-
-    def authentication_challenge
-      services.authz.challenge(:realm => "Roadforest")
-    end
-
-    def canonical_host
-      services.canonical_host
-    end
-
-    def canonical_uri
-      url_for(route_name, params)
-    end
-
-    def type_handling
-      services.type_handling
-    end
-
-    def my_path
-      path_for(route_name, params)
-    end
-
-    def my_url
-      canonical_uri.to_s
-    end
-
-    def reset
-    end
-
-    def exists?
-      !data.nil?
-    end
-
-    def etag
-      nil
-    end
-
-    def last_modified
-      nil
-    end
-
-    def response_location
-      @response_values.fetch(:location) do
-        raise ProcessingSequenceError, "Location not available until request processed"
-      end
-    end
-
-    def response_location=(location)
-      @response_values[:location] = location
-    end
-
-    def response_data
-      @response_values.fetch(:data) do
-        raise ProcessingSequenceError, "Location not available until request processed"
-      end
-    end
-
-    def response_data=(data)
-      @response_values[:data] = data
-    end
-
-    def processed
-      [:location, :data].each do |key|
-        unless @response_values.has_key?(key)
-          @response_values[key] = nil
-        end
-      end
-    end
-
-    def expires
-      nil
-    end
-
-    def update(data)
-      raise NotImplementedError
-    end
-
-    def add_child(results)
-      raise NotImplementedError
-    end
-
-    def retrieve
-      raise NotImplementedError
-    end
-    alias retreive retrieve
-
-    def delete
-      false
-    end
-
-  end
-
-  class RDFModel < Model
-    include RDF::Etagging
-
-    def update(graph)
-      graph_update(start_focus(graph))
-    end
-
-    def graph_update(focus)
-      fill_graph(focus)
-    end
-
-    def add_graph_child(graph)
-      add_child(start_focus(graph))
-      new_graph
-    end
-
-    def add_child(focus)
-      new_graph
-    end
-
-    def retrieve
-      new_graph
-    end
-
-    def fill_graph(graph)
-    end
-
-    def start_focus(graph, resource_url=nil)
-      access = RDF::WriteManager.new
-      access.source_graph = graph
-      focus = RDF::GraphFocus.new(access, resource_url || my_url)
-
-      yield focus if block_given?
-      return focus
-    end
-
-    def copy_model(node, route_name, params=nil)
-      params ||= {}
-
-      url = url_for(route_name, params)
-      source_model = model_for(route_name, params)
-
-      access = RDF::CopyManager.new
-      access.source_graph = source_model.current_graph
-      access.target_graph = node.access_manager.destination_graph
-      copier = RDF::GraphFocus.new(access, url)
-
-      yield copier if block_given?
-      copier
-    end
-
-    def etag
-      @etag ||= etag_from(etag_graph)
-    end
-
-    def etag_graph
-      current_graph
-    end
-
-    def current_graph
-      return response_data if response_values.has_key?(:data)
-      new_graph
-    end
-
-    def new_graph
-      graph = ::RDF::Graph.new
-      focus = start_focus(graph, my_url)
-      fill_graph(focus)
-      self.response_data = graph
-    end
-  end
-end

data/lib/roadforest/models.rb

@@ -1,2 +0,0 @@
-require 'roadforest/model'
-require 'roadforest/blob-model'

data/lib/roadforest/rdf/source-rigor.rb

@@ -1,44 +0,0 @@
-require 'roadforest'
-
-module RoadForest::RDF
-  class SourceRigor
-    require 'roadforest/rdf/source-rigor/investigator'
-    require 'roadforest/rdf/source-rigor/credence'
-
-    class << self
-      def simple
-        rigor = self.new
-        rigor.policy_list(:must_local, :may_local)
-        rigor.investigator_list(:null)
-        rigor
-      end
-
-      def http
-        rigor = self.new
-        rigor.policy_list(:may_subject, :any) #XXX
-        rigor.investigator_list(:http, :null)
-        rigor
-      end
-    end
-
-    def initialize
-      @investigators = []
-      @investigation_limit = 3
-      @credence_policies = []
-    end
-
-    attr_accessor :graph_transfer, :investigators, :investigation_limit, :credence_policies
-
-    def policy_list(*names)
-      self.credence_policies = names.map do |name|
-        Credence.policy(name)
-      end
-    end
-
-    def investigator_list(*names)
-      self.investigators = names.map do |name|
-        Investigator[name].new
-      end
-    end
-  end
-end

data/lib/roadforest/rdf/vocabulary.rb

@@ -1,11 +0,0 @@
-require 'roadforest/rdf'
-
-module RoadForest::RDF
-  module Vocabulary
-    class RF < ::RDF::Vocabulary("http://lrdesign.com/rdf/roadforest#")
-      property :Impulse
-      property :impulse
-      property :begunAt
-    end
-  end
-end

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

@@ -1,81 +0,0 @@
-=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.rb

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

data/spec/form-parsing.rb

@@ -1 +0,0 @@
-require 'roadforest/resource/http/form-parsing'