roadforest 0.0.1

data/lib/roadforest/rdf/parcel.rb

@@ -0,0 +1,47 @@
+require 'roadforest/rdf'
+require 'roadforest/rdf/normalization'
+
+module RoadForest::RDF
+  class Parcel
+    include Normalization
+
+    attr_accessor :graph
+
+    def resources
+      resource_hash = {}
+      graph.each_subject do |subject|
+        next unless RDF::URI === subject
+        resource_hash[normalize_context(subject)] = true
+      end
+      resource_hash.keys
+    end
+
+    def subjects_for_resource(resource)
+      resource = normalize_context(resource)
+      graph.each_subject.find_all do |subject|
+        normalize_context(subject) == resource
+      end
+    end
+
+    def graph_for(resource)
+      new_graph = RDF::Graph.new
+      subjects = {}
+      subjects_for_resource(resource).each do |subject|
+        subjects[subject] ||= :open
+      end
+
+      until (open_subjects = subjects.keys.find_all{|subject| subjects[subject] == :open }).empty?
+        open_subjects.each do |subject|
+          subjects[subject] = :closed
+          graph.query(:subject => subject) do |statement|
+            if RDF::Node === statement.object
+              subjects[statement.object] ||= :open
+            end
+            new_graph << statement
+          end
+        end
+      end
+      new_graph
+    end
+  end
+end

data/lib/roadforest/rdf/post-focus.rb

@@ -0,0 +1,35 @@
+require 'roadforest/rdf/graph-focus'
+
+module RoadForest::RDF
+  class PostFocus < GraphFocus
+    def initialize(subject = nil, graph = nil , rigor = nil)
+      super(subject, graph, rigor)
+      @graphs = {}
+    end
+    attr_accessor :graphs
+
+    def dup
+      other = super
+      other.graphs = graphs
+      other
+    end
+
+    def graph_transfer
+      source_rigor.graph_transfer
+    end
+
+    def post_to
+      graph = ::RDF::Graph.new
+      focus = GraphFocus.new(subject, graph, source_rigor) #XXX non-client version
+      graphs[subject] = graph
+      yield focus if block_given?
+      return focus
+    end
+
+    def send_graphs
+      @graphs.each_pair do |url, graph|
+        graph_transfer.post(url, graph)
+      end
+    end
+  end
+end

data/lib/roadforest/rdf/resource-pattern.rb

@@ -0,0 +1,60 @@
+require 'rdf/query/pattern'
+require 'roadforest/rdf'
+require 'roadforest/rdf/investigation'
+
+module RoadForest::RDF
+  class ResourcePattern < ::RDF::Query::Pattern
+    def self.from(pattern, options)
+      pattern = case pattern
+                when self
+                  pattern
+                when ::RDF::Query::Pattern
+                  options ||= {}
+                  self.new(pattern.subject, pattern.predicate, pattern.object, options.merge(:context => pattern.context))
+                when Array, ::RDF::Statement
+                  options ||= {}
+                  self.new(pattern[0], pattern[1], pattern[2], options.merge(:context => pattern[3]))
+                when Hash
+                  options ||= {}
+                  self.new(options.merge(pattern))
+                else
+                  raise ArgumentError, "expected RoadForest::RDF::ResourcePattern, RDF::Query::Pattern, RDF::Statement, Hash, or Array, but got #{pattern.inspect}"
+                end
+
+      unless options.nil?
+        pattern.context_roles = options[:context_roles]
+        pattern.source_rigor = options[:source_rigor]
+      end
+
+      yield pattern if block_given?
+
+      pattern
+    end
+
+    attr_accessor :context_roles, :source_rigor
+
+    def execute(queryable, bindings = nil, query_context_roles = nil, &block)
+      unless queryable.is_a? RoadForest::RDF::GraphStore
+        return super(queryable, bindings || {}, &block)
+      end
+
+      investigation = Investigation.new
+      investigation.queryable = queryable
+      investigation.context_roles = (query_context_roles || {}).merge(context_roles)
+      investigation.source_rigor = source_rigor
+
+      results = investigation.result do |results|
+        super(queryable, bindings || {}) do |statement|
+          results << statement
+        end
+      end
+
+      results.each(&block) if block_given?
+      results
+    end
+
+    def context
+      @context ||= ::RDF::Query::Variable.new(:context)
+    end
+  end
+end

data/lib/roadforest/rdf/resource-query.rb

@@ -0,0 +1,58 @@
+require 'roadforest/rdf'
+require 'rdf/query'
+
+module RoadForest::RDF
+  class ResourceQuery < ::RDF::Query
+    def initialize(patterns = [], options = {}, &block)
+      @subject_context = options[:subject_context]
+      @source_rigor = options[:source_rigor]
+      super
+      patterns = @patterns.dup
+      @patterns.clear
+      patterns.each do |pattern|
+        pattern(pattern)
+      end
+    end
+
+    attr_accessor :subject_context, :source_rigor
+    attr_accessor :patterns, :variables, :solutions, :options
+
+    def <<(pattern)
+      pattern(pattern)
+    end
+
+    def pattern(pattern, options = nil)
+      options = {
+        :context_roles => {:subject => subject_context},
+        :source_rigor => source_rigor
+      }.merge(options || {})
+
+      @patterns << ResourcePattern.from(pattern, options)
+      self
+    end
+
+    def self.from(other, subject_context = nil, source_rigor = nil)
+      query = self.new
+
+      if subject_context.nil? and other.respond_to?(:subject_context)
+        query.subject_context = other.subject_context
+      else
+        query.subject_context = subject_context
+      end
+
+      if source_rigor.nil? and other.respond_to?(:source_rigor)
+        query.source_rigor = other.source_rigor
+      else
+        query.source_rigor = source_rigor
+      end
+
+      other.patterns.each do |pattern|
+        query.pattern(pattern)
+      end
+      query.variables = other.variables
+      query.solutions = other.solutions
+      query.options = other.options
+      return query
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+class RoadForest::RDF::SourceRigor
+  module Credence
+    class Any
+      def credible(contexts, results)
+        contexts
+      end
+    end
+  end
+end

data/lib/roadforest/rdf/source-rigor/credence/none-if-role-absent.rb

@@ -0,0 +1,19 @@
+class RoadForest::RDF::SourceRigor
+  module Credence
+    #Unless we have results for the subject context, nothing is valid
+    class NoneIfRoleAbsent
+      def initialize(role)
+        @role = role
+      end
+      attr_reader :role
+
+      def credible(contexts, results)
+        if contexts.include?(results.context_roles[role])
+          contexts
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/roadforest/rdf/source-rigor/credence/role-if-available.rb

@@ -0,0 +1,19 @@
+class RoadForest::RDF::SourceRigor
+  module Credence
+    #If there are any results for the subject context, they're good
+    class RoleIfAvailable
+      def initialize(role)
+        @role = role
+      end
+      attr_reader :role
+
+      def credible(contexts, results)
+        if contexts.include?(results.context_roles[role])
+          [results.context_roles[role]]
+        else
+          contexts
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'roadforest/rdf'
+
+class RoadForest::RDF::SourceRigor
+  class CredenceAnnealer
+    def initialize(graph)
+      @graph = graph
+      @attempts = 5
+    end
+
+    attr_accessor :attempts
+
+    def resolve(&block)
+      attempts = @attempts
+
+      begin
+        raise "Annealing failed after #@attempts attempts" if (attempts -= 1) < 0
+        @graph.next_impulse
+        block.call
+      end until @graph.quiet_impulse?
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+class RoadForest::RDF::SourceRigor
+  module Credence
+    require 'roadforest/rdf/source-rigor/credence/role-if-available'
+    require 'roadforest/rdf/source-rigor/credence/any'
+    require 'roadforest/rdf/source-rigor/credence/none-if-role-absent'
+
+    def self.policies
+      @policies ||= {
+        :any => Any.new,
+        :may_subject => RoleIfAvailable.new(:subject),
+        :must_subject => NoneIfRoleAbsent.new(:subject),
+        :may_local => RoleIfAvailable.new(:local),
+        :must_local => NoneIfRoleAbsent.new(:local)
+      }
+    end
+
+    def self.policy(name)
+      if block_given?
+        policies[name] ||= yield
+      else
+        begin
+          policies.fetch(name)
+        rescue KeyError
+          raise "No Credence policy for #{name.inspect} (available named policies are #{policies.keys.inspect})"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'roadforest/rdf/source-rigor/investigator'
+class RoadForest::RDF::SourceRigor
+  class HTTPInvestigator < Investigator
+    register :http
+
+    def pursue(investigation)
+      response = investigation.make_request("GET", investigation.context_roles[:subject])
+      case response.status
+      when (200..299)
+        investigation.insert_graph(response.url, response.graph)
+      when (300..399)
+        #client should follow redirects
+      when (400..499)
+      when (500..599)
+        raise NotCredible #hrm
+      end
+    rescue NotCredible
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'roadforest/utility/class-registry'
+
+class RoadForest::RDF::SourceRigor
+  class NotCredible < StandardError; end
+  class NoCredibleResults < StandardError; end
+
+  class Investigator
+    extend ::RoadForest::Utility::ClassRegistry::Registrar
+    def self.registry_purpose; "investigator"; end
+
+    def pursue(investigation)
+      raise NoCredibleResults
+    end
+  end
+end
+require 'roadforest/rdf/source-rigor/null-investigator'
+require 'roadforest/rdf/source-rigor/http-investigator'

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

@@ -0,0 +1,10 @@
+require 'roadforest/rdf/source-rigor/investigator'
+class RoadForest::RDF::SourceRigor
+  class NullInvestigator < Investigator
+    register :null
+
+    def pursue(investigation)
+      investigation.results = []
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+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/update-focus.rb

@@ -0,0 +1,73 @@
+require 'roadforest/rdf/graph-focus'
+require 'roadforest/rdf/parcel'
+
+module RoadForest::RDF
+  class UpdateFocus < GraphFocus
+    attr_accessor :target_graph
+
+    alias source_graph= graph=
+    alias source_graph graph
+
+    def dup
+      other = super
+      other.target_graph = target_graph
+      other
+    end
+
+    def parceller
+      @parceller ||=
+        begin
+          parceller = Parcel.new
+          parceller.graph = source_graph
+          parceller
+        end
+    end
+
+    def copy_context
+      unless target_graph.has_context?(root_url)
+        parceller.graph_for(root_url).each_statement do |statement|
+          statement.context = root_url
+          target_graph << statement
+        end
+      end
+    end
+
+    def add(property, value, extra=nil)
+      copy_context
+      property, value = normalize_triple(property, value, extra)
+      target_graph.insert([subject, property, value, root_url])
+    end
+
+    def set(property, value, extra=nil)
+      copy_context
+      super
+    end
+
+    def delete(property, extra=nil)
+      copy_context
+      property, value = normalize_triple(property, value, extra)
+      target_graph.query([subject, property]) do |statement|
+        target_graph.delete(statement)
+      end
+    end
+
+    def query_value(query)
+      source_result = super
+      target_result = query.execute(target_graph).map do |solution|
+        unwrap_value(solution.value)
+      end
+
+      if target_result.empty?
+        source_result
+      else
+        target_result
+      end
+    end
+
+    def wrap_node(value)
+      focus = super
+      focus.target_graph = self.target_graph
+      focus
+    end
+  end
+end

data/lib/roadforest/rdf/vocabulary.rb

@@ -0,0 +1,11 @@
+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/rdf.rb

@@ -0,0 +1,6 @@
+require 'rdf'
+
+module RoadForest
+  module RDF
+  end
+end

data/lib/roadforest/remote-host.rb

@@ -0,0 +1,96 @@
+require 'roadforest/rdf/source-rigor'
+require 'roadforest/rdf/source-rigor/credence-annealer'
+require 'roadforest/http/graph-transfer'
+require 'roadforest/http/adapters/excon'
+require 'roadforest/rdf/graph-store'
+
+module RoadForest
+  class RemoteHost
+    include RDF::Normalization
+
+    def initialize(well_known_url)
+      @url = normalize_resource(well_known_url)
+      @graph = build_graph_store
+    end
+
+    def build_graph_store
+      RDF::GraphStore.new
+    end
+
+    attr_writer :http_client
+    def http_client
+      @http_client ||= HTTP::ExconAdapter.new(@url)
+    end
+
+    def graph_transfer
+      @graph_transfer ||= HTTP::GraphTransfer.new.tap do |transfer|
+        transfer.http_client = http_client
+      end
+    end
+
+    def source_rigor
+      @source_rigor ||=
+        begin
+          rigor = RDF::SourceRigor.http
+          rigor.graph_transfer = graph_transfer
+          rigor
+        end
+    end
+
+    def render_graph(graph)
+      Resource::ContentType::JSONLD.from_graph(graph)
+    end
+
+    def anneal(focus)
+      annealer = RDF::SourceRigor::CredenceAnnealer.new(@graph)
+      annealer.resolve do
+        yield focus
+      end
+    end
+
+    def putting(&block)
+      require 'roadforest/rdf/update-focus'
+      target_graph = ::RDF::Repository.new
+      updater = RDF::UpdateFocus.new(@url, @graph, source_rigor)
+      updater.target_graph = target_graph
+
+      anneal(updater, &block)
+
+      target_graph.each_context do |context|
+        graph = ::RDF::Graph.new(context, :data => target_graph)
+        graph_transfer.put(context, graph)
+      end
+    end
+
+    def posting(&block)
+      require 'roadforest/rdf/post-focus'
+      poster = RDF::PostFocus.new(@url, @graph, source_rigor)
+
+      anneal(poster, &block)
+
+      poster.send_graphs
+    end
+
+    def getting(&block)
+      reader = RDF::GraphReading.new(@url, @graph, source_rigor)
+
+      anneal(reader, &block)
+    end
+
+    def put_file(destination, type, io)
+      if destination.respond_to?(:to_context)
+        destination = destination.to_context
+      elsif destination.respond_to?(:to_s)
+        destination = destination.to_s
+      end
+      request = HTTP::Request.new("PUT", destination)
+      request.body = io
+      request.headers["Content-Type"] = type
+      response = http_client.do_request request
+    end
+
+    #TODO:
+    #def deleting
+    #def patching
+  end
+end

data/lib/roadforest/resource/handlers.rb

@@ -0,0 +1,43 @@
+require 'roadforest/application/route-adapter'
+
+module RoadForest
+  module Resource
+    module Handlers
+      def self.registry
+        @registry ||= {}
+      end
+
+      def self.register(handler_type, klass)
+        registry[handler_type] = klass
+
+        method_name = "#{handler_type}_model"
+        define_method(method_name) do |model_class|
+          if block_given?
+            bundle_model(klass, model_class){|model| yield(model)}
+          else
+            bundle_model(klass, model_class)
+          end
+        end
+      end
+
+      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::Handlers.registry.fetch(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::Handlers.registry.fetch(resource_type)
+        bundle(resource_class) do |resource, request, response|
+          resource.model = model_class.new(route_name, resource.params, services)
+          resource.trace = true
+        end
+      end
+    end
+  end
+end