roadforest 0.0.1

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

@@ -0,0 +1,95 @@
+require 'rdf'
+require 'roadforest/rdf/context-fascade'
+require 'roadforest/rdf/focus-wrapping'
+require 'roadforest/rdf/graph-reading'
+
+module RoadForest::RDF
+  class GraphCollection
+    include Enumerable
+  end
+
+  class MultivaluedProperty < GraphCollection
+    attr_reader :graph, :subject, :property
+    def initialize(graph, subject, property)
+      @graph, @subject, @propery = graph, subject, property
+    end
+
+    def values
+      query_value(graph, subject, property)
+    end
+
+    def each
+      if block_given?
+        other
+        values.each do |value|
+          yield unwrap_value(value)
+        end
+      else
+        values.each
+      end
+    end
+
+    def add(value)
+      add_statement(subject, property, value)
+    end
+  end
+
+  module GraphWriting
+    def normalize_triple(property, value, extra=nil)
+      if not extra.nil?
+        property = [property, value]
+        value = extra
+      end
+      return normalize_property(property), normalize_term(value)
+    end
+
+    def set(property, value, extra=nil)
+      property, value = normalize_triple(property, value, extra)
+
+      delete(property)
+      add(property, value)
+      return value
+    end
+    alias_method :[]=, :set
+
+    def add(property, value, extra=nil)
+      property, value = normalize_triple(property, value, extra)
+
+      target_graph.insert([subject, property, value])
+      return value
+    end
+
+    def delete(property, extra=nil)
+      target_graph.delete([subject, normalize_property(property, extra), :value])
+    end
+
+    def set_node(property, url=nil)
+      node = wrap_node(set(property, normalize_resource(url) || RDF::Node.new))
+      yield node if block_given?
+      node
+    end
+    alias node_at set_node
+
+    def add_node(property, url=nil)
+      node = wrap_node(add(property, normalize_resource(url) || RDF::Node.new))
+      yield node if block_given?
+      node
+    end
+
+    def add_list(property, extra=nil)
+      list = ::RDF::List.new(nil, target_graph)
+      target_graph.insert([subject, normalize_property(property, extra), list.subject])
+      yield list if block_given?
+      return list
+    end
+  end
+
+  class GraphFocus < GraphReading
+    include GraphWriting
+
+    def target_graph
+      graph
+    end
+
+  end
+end

data/lib/roadforest/rdf/graph-reading.rb

@@ -0,0 +1,145 @@
+require 'roadforest/rdf/focus-list'
+require 'roadforest/rdf/normalization'
+require 'roadforest/rdf/focus-wrapping'
+require 'roadforest/rdf/resource-query'
+
+module RoadForest::RDF
+  class GraphReading
+    include Normalization
+    include FocusWrapping
+
+    attr_accessor :graph, :subject, :root_url, :source_rigor
+    alias rdf subject
+
+    def initialize(subject = nil, graph = nil, rigor = nil)
+      @graph = nil
+      @subject = nil
+      @root_url = nil
+      @source_rigor = nil
+      self.subject = subject unless subject.nil?
+      self.graph = graph unless graph.nil?
+      self.source_rigor = rigor unless rigor.nil?
+    end
+
+    def inspect
+      "#<#{self.class.name}:0x#{"%x" % object_id} (#{subject.to_s}) #{forward_properties.inspect}>"
+    end
+
+    def dup
+      other = self.class.new
+      other.graph = graph
+      other.subject = subject
+      other.root_url = root_url
+      other.source_rigor = source_rigor
+      other
+    end
+
+    def to_context
+      normalize_context(subject)
+    end
+
+    def root_url=(*value) #XXX curies?
+      @root_url = normalize_resource(value)
+    end
+
+    def subject=(*value)
+      @subject = normalize_resource(value)
+      case @subject
+      when ::RDF::URI
+        @root_url ||= @subject
+      end
+    end
+
+    def build_query
+      ResourceQuery.new([], {}) do |query|
+        query.subject_context = @root_url
+        query.source_rigor = @source_rigor
+        yield query
+      end
+    end
+
+    def forward_properties
+      query_properties( build_query{|q| q.pattern([ normalize_resource(subject), :property, :value ])} )
+    end
+
+    def reverse_properties
+      query_properties( build_query{|q| q.pattern([ :value, :property, normalize_resource(subject)])} )
+    end
+
+    def get(prefix, property = nil)
+      return single_or_enum(forward_query_value( prefix, property))
+    end
+    alias_method :[], :get
+
+    def first(prefix, property = nil)
+      return forward_query_value( prefix, property ).first
+    end
+
+    def all(prefix, property = nil)
+      return forward_query_value( prefix, property )
+    end
+
+    #XXX Maybe rev should return a decorator, so it looks like:
+    #focus.rev.get(...) or focus.rev.all(...)
+    def rev(prefix, property = nil)
+      return single_or_enum(reverse_query_value( prefix, property))
+    end
+
+    def rev_first(prefix, property = nil)
+      return reverse_query_value(prefix, property).first
+    end
+
+    def rev_all(prefix, property = nil)
+      return reverse_query_value(prefix, property)
+    end
+
+    def as_list
+      graph = ContextFascade.new(@graph, @root_url, @source_rigor)
+      list = FocusList.new(@subject, graph)
+      list.base_node = self
+      list.source_rigor = source_rigor
+      list
+    end
+
+    protected
+
+    def reverse_query_value(prefix, property=nil)
+      query_value(build_query{|q|
+        q.pattern([ :value, normalize_property(prefix, property), normalize_resource(subject)])
+      })
+    end
+
+    def forward_query_value(prefix, property=nil)
+      query_value(build_query{|q|
+        q.pattern([ normalize_resource(subject), normalize_property(prefix, property), :value])
+      })
+    end
+
+    def query_value(query)
+      solutions = query.execute(graph)
+      solutions.map do |solution|
+        unwrap_value(solution.value)
+      end
+    end
+    def single_or_enum(values)
+      case values.length
+      when 0
+        return nil
+      when 1
+        return values.first
+      else
+        return values.enum_for(:each)
+      end
+    end
+
+    def query_properties(query)
+      Hash[query.execute(graph).map do |solution|
+        prop = solution.property
+        if qname = prop.qname
+          prop = qname
+        end
+        [prop, solution.value]
+      end]
+    end
+  end
+end

data/lib/roadforest/rdf/graph-store.rb

@@ -0,0 +1,217 @@
+require 'rdf'
+require 'roadforest/rdf/graph-focus'
+require 'roadforest/rdf/vocabulary'
+require 'roadforest/rdf/normalization'
+
+require 'roadforest/rdf/resource-query'
+require 'roadforest/rdf/resource-pattern'
+
+module RoadForest::RDF
+  class GraphStore
+    include Normalization
+
+    #The interface supported by ::RDF::Graph
+    include ::RDF::Countable
+    include ::RDF::Durable
+    include ::RDF::Enumerable
+    include ::RDF::Mutable
+    include ::RDF::Queryable
+    include ::RDF::Resource
+
+    attr_reader :repository, :current_impulse, :local_context_node
+    attr_accessor :debug_io
+
+    def initialize(repo = nil)
+      @repository = repo || RDF::Repository.new
+      @local_context_node = RDF::Node.new(:local)
+      @debug_io = nil
+      next_impulse
+      yield self if block_given?
+    end
+
+    def next_impulse
+      return if !@current_impulse.nil? and raw_quiet_impulse?
+      #mark ended?
+      #chain impulses?
+      @current_impulse = RDF::Node.new
+      repository.insert(normalize_statement(@current_impulse, [:rdf, 'type'], [:rf, 'Impulse'], nil))
+      repository.insert(normalize_statement(@current_impulse, [:rf, 'begunAt'], Time.now, nil))
+    end
+
+    def quiet_impulse?
+      raw_quiet_impulse?
+    end
+
+    def raw_quiet_impulse?
+      repository.query([nil, nil, @current_impulse, false]).to_a.empty?
+    end
+
+    #repo cleanup - expired graphs
+
+    def reader_for(content_type, repository)
+      RDF::Reader.for(content_type)
+    end
+
+    def debug(message)
+      return if @debug_io.nil?
+      @debug_io.puts(message)
+    end
+
+    def repository_dump(format = :turtle)
+      repository.dump(format)
+    end
+    alias graph_dump repository_dump
+
+    def delete_statements(pattern)
+      repository.delete(pattern)
+    end
+
+    def named_graph(context)
+      ::RDF::Graph.new(context, :data => repository)
+    end
+
+    def named_list(context, values = nil)
+      ::RDF::List.new(nil, named_graph(context), values)
+    end
+
+    def create_list(values = nil)
+      named_list(local_context_node, values)
+    end
+
+    def insert_document(document)
+      #puts; puts "#{__FILE__}:#{__LINE__} => #{(document).inspect}"
+      #puts document.body_string
+      reader = RDF::Reader.for(:content_type => document.content_type) do
+        sample = document.body.read(1000)
+        document.body.rewind
+        sample
+      end.new(document.body, :base_uri => document.root_url) #consider :processor_graph
+      insert_reader(document.source, reader)
+    end
+
+    def insert_reader(context, reader)
+      #puts; puts "#{__FILE__}:#{__LINE__} => #{(context).inspect}"
+      context = normalize_context(context)
+      delete_statements(:context => context)
+      reader.each_statement do |statement|
+        statement.context = context
+        record_statement(statement)
+      end
+      #puts; puts "#{__FILE__}:#{__LINE__} => \n#{(graph_dump(:nquads))}"
+    end
+
+    def insert_graph(context, graph)
+      context = normalize_context(context)
+      delete_statements(:context => context)
+      graph.each_statement do |statement|
+        statement.context = context
+        record_statement(statement)
+      end
+    end
+
+    def add_statement(*args)
+      case args.length
+      when 1
+        subject, predicate, object, context = *args.first
+      when 2
+        triple, context = *args
+        subject, predicate, object = *triple
+      when 3
+        subject, predicate, object = *args
+        context = nil
+      when 4
+        subject, predicate, object, context = *args
+      else
+        raise ArgumentError, "insert_statement needs some variation of subject, predicate, object, [context]"
+      end
+      context ||= local_context_node
+
+      record_statement(normalize_statement(subject, predicate, object, context))
+    end
+
+    def insert_statement(statement)
+      repository.insert(statement)
+
+      repository.delete([statement.context, expand_curie([:rf, "impulse"]), nil])
+      repository.insert(normalize_statement(statement.context, [:rf, "impulse"], current_impulse, nil))
+    end
+    alias record_statement insert_statement
+
+    def delete_statement(statement)
+      repository.query(statement) do |statement|
+        next if statement.context.nil?
+        repository.delete(statement)
+      end
+    end
+
+    def replace(original, statement)
+      unless original == statement
+        repository.delete(original)
+        repository.insert(statement)
+      end
+    end
+
+    def each_statement(context=nil, &block)
+      query = {}
+      unless context.nil?
+        query[:context] = context
+      end
+
+      @repository.query(query) do |statement|
+        yield statement
+      end
+    end
+
+    def durable?
+      @repository.durable?
+    end
+
+    #XXX Credence? Default context?
+    def each(&block)
+      if @repository.respond_to?(:query)
+        @repository.query(:context => false, &block)
+      elsif @repository.respond_to?(:each)
+        @repository.each(&block)
+      else
+        @repository.to_a.each(&block)
+      end
+    end
+
+    #XXX Needed, maybe, if we need to handle constant patterns
+    #def include?(statement)
+    #end
+
+    def context_variable
+      @context_variable ||= RDF::Query::Variable.new(:context)
+    end
+
+    def query_execute(query, &block)
+      #XXX Weird edge case of GM getting queried with a vanilla RDF::Query...
+      #needs tests, thought
+      query = ResourceQuery.from(query)
+      query.execute(self).filter do |solution|
+        solution.respond_to?(:context) and not solution.context.nil?
+      end.each(&block)
+    end
+
+    def query_pattern(pattern, &block)
+      case pattern
+      when ResourcePattern
+        pattern.execute(@repository, {}, :context_roles => {:local => local_context_node}) do |statement|
+          next if statement.context.nil?
+          yield statement if block_given?
+        end
+      else
+        pattern.execute(@repository, {}) do |statement|
+          next if statement.context.nil?
+          yield statement if block_given?
+        end
+      end
+    end
+
+    def unnamed_graph
+      ::RDF::Graph.new(nil, :data => @repository)
+    end
+
+  end
+end

data/lib/roadforest/rdf/investigation.rb

@@ -0,0 +1,90 @@
+require 'roadforest/rdf'
+
+module RoadForest::RDF
+  class Investigation
+    attr_accessor :context_roles, :queryable, :results, :source_rigor
+
+    def initialize
+      @results = []
+    end
+
+    def http_client
+      queryable.http_client
+    end
+
+    def found_results?
+      !@results.nil?
+    end
+
+    def investigators
+      source_rigor.investigators
+    end
+
+    def credence_policies
+      source_rigor.credence_policies
+    end
+
+    def make_request(method, url, graph=nil)
+      source_rigor.graph_transfer.make_request(method, url, graph)
+    end
+
+
+    def insert_graph(context, graph)
+      queryable.insert_graph(context, graph)
+    end
+
+    def result
+      investigators.each do |investigator|
+        self.results = []
+        yield(results)
+
+        contexts = result_contexts
+
+        catch :not_credible do
+          credence_policies.each do |policy|
+            contexts = policy.credible(contexts, self)
+            if contexts.empty?
+              throw :not_credible
+            end
+          end
+          return results_for_context(contexts.first)
+        end
+
+        self.results = nil
+        investigator.pursue(self)
+
+        if found_results?
+          return results
+        end
+      end
+      raise NoCredibleResults
+    end
+
+    def result_contexts
+      (results.map(&:context) +
+       context_roles.values.find_all do |context|
+        not context_metadata(context).empty?
+       end).uniq
+    end
+
+    def context_metadata(context)
+      query = RDF::Query.new do |query|
+        query.pattern [context, :property, :value]
+      end
+      query.execute(queryable.unnamed_graph).select(:property, :value)
+    end
+
+    def results_for_context(context)
+      results.find_all{|item| item.context == context}
+    end
+
+    #XXX Do we need the nil result if context_metadata is empty?
+    def empty_for_context(context)
+      if context_metadata(context).empty? #We've never checked
+        nil
+      else
+        empty_result
+      end
+    end
+  end
+end

data/lib/roadforest/rdf/normalization.rb

@@ -0,0 +1,150 @@
+require 'rdf'
+
+module RoadForest::RDF
+  module Normalization
+    Vocabs = {}
+    Vocabs["rdf"] = RDF
+
+    def normalize_statement(subject, predicate, object, context)
+      subject = normalize_resource(subject) || RDF::Node.new
+      predicate = normalize_uri(predicate)
+      object = normalize_term(object) || RDF::Node.new
+      context = normalize_resource(context)
+
+      RDF::Statement.new(subject, predicate, object, :context => context)
+    end
+
+    def normalize_tuple(tuple)
+      subject, predicate, object, context = *tuple
+      [ normalize_resource(subject) || RDF::Node.new, normalize_uri(predicate), normalize_term(object) || RDF::Node.new, normalize_resource(context) ]
+    end
+
+    def normalize_resource(from)
+      from = expand_curie(from)
+      case from
+      when nil
+      when RDF::Resource
+      when /^_:/
+        from = RDF::Resource.new(from)
+      when String, RDF::URI, Addressable::URI
+        from = interned_uri(from)
+      when Symbol
+        from = RDF::Node.new(from)
+      else
+        from = RDF::Resource.new(from)
+      end
+      return from
+    end
+
+    def normalize_context(from)
+      case from
+      when Array
+        from = expand_curie(from)
+      when RDF::URI, Addressable::URI, String
+        from = uri(from)
+      else
+        return nil
+      end
+      from.fragment = nil
+      return RDF::URI.intern(from.to_s)
+    end
+
+    def normalize_uri(from)
+      from = expand_curie(from)
+      case from
+      when nil
+      when RDF::URI
+      else
+        from = interned_uri(from)
+      end
+      return from
+    end
+
+    def normalize_term(object)
+      if Array === object
+        RDF::Resource.new(expand_curie(object))
+      else
+        object
+      end
+    end
+
+    def literal(object)
+      RDF::Literal.new(object)
+    end
+
+    def expand_curie_pair(prefix, property)
+      vocab = Vocabs.fetch(prefix) do
+        vocab = RDF::Vocabulary.find do |vocab|
+          vocab.__prefix__.to_s == prefix
+        end
+        #p k => vocab #ok
+        if vocab.nil?
+          raise "Don't know a vocabulary for prefix #{prefix.inspect} in CURIE #{prefix}:#{property}"
+        end
+        Vocabs[prefix] = vocab
+        vocab
+      end
+      vocab[property]
+    end
+
+    def expand_curie(from)
+      case from
+      when Array
+        case from.length
+        when 2
+          prefix, property = *from
+          return interned_uri(expand_curie_pair(prefix.to_s, property.to_s))
+        when 1
+          return expand_curie(from.first)
+        else
+          return from
+        end
+      else
+        return from
+      end
+    end
+
+    def normalize_property(prefix, property = nil)
+      if property.nil?
+        property = prefix
+
+        case property
+        when Array
+          normalize_property(*property)
+        when String
+          RDF::URI.intern(property)
+        else
+          property
+        end
+      else
+        expand_curie([prefix, property])
+      end
+    end
+
+    def root_url
+      nil
+    end
+
+    def interned_uri(value)
+
+      RDF::URI.intern(uri(value))
+    end
+
+    def uri(value)
+      if root_url
+        value = root_url.join(value)
+      else
+        value = RDF::URI.new(value)
+      end
+
+      if !value.query.nil? and value.query.empty?
+        value.query = nil
+      end
+      value.validate!
+      value.canonicalize!
+
+      value
+    end
+  end
+
+end