activesesame 0.1.0

data/lib/active_sesame/owl_thing.rb

@@ -0,0 +1,92 @@
+class ActiveSesame::OwlThing
+  require 'digest/sha1'
+  include ActiveSesame::Support
+  #class methods for building the definition of the class
+  # - The most basic definition should (when inheriting from OwlThing create the subClassOf triple
+  # - The init method is the same for all even owl thing
+  #init for creating a new instance of the thing
+  # - A method to create a uri for the thing
+  # - - This could be <blank> as well
+
+  # OwlThing.new creates a new term that is a rdf:type of owl:Thing
+  # when a class is created that inherits from OwlThing the definition for the class term is yet another instantiation of owl thing that can be placed in a class attribute
+  # new results in rdf:type relationship, inherited results in rdfs:subClassOf relationship
+
+  # Use class attribute term as the place for keeping
+  # Pass in the uri and object through the new() when inherited as called
+  # Questions to be answered:
+  # -Does self.add_triple/term.add_relationships overwrite relationships or always add to unsaved_triples?
+
+
+  # TODO:
+  # -Be sure that if the term exists that it will populate relationships and what not appropriately
+  # -Be sure the "unsaved triples" are not added when the triple already exists
+  # -Add find methods:
+  # --Find for uri (id equivalent)
+  # --find(:all)
+  # --find(:all/:first, :conditions => "?self rdf:type #{self.class.term.term} . user input" (made with sparql query object?)
+
+  class << self
+    attr_accessor :repository, :term, :uri
+  end
+
+  attr_accessor :uri, :term
+
+  def self.inherited(klass)
+    klass.term.add_triple({:subject => "base:#{klass}", :predicate => "rdfs:subClassOf", :object => "owl:Thing"})
+  end
+
+  def self.repository
+    @repository ||= self.repository = ActiveSesame::Repository.new #Setting default repository
+  end
+
+  def self.set_repository(repo)
+    self.repository = repo
+    self.reset_term
+  end
+
+  def self.uri
+    @uri ||= "base:" + self.to_s.split("::").last
+  end
+
+  def self.set_uri(uri)
+    self.uri = uri
+    self.reset_term
+  end
+
+  def self.term
+    @term ||= ActiveSesame::Ontology::Term.new(uri, self.repository)
+  end
+
+  def self.reset_term
+    @term = ActiveSesame::Ontology::Term.new(uri, self.repository)
+    @term.add_triple({:subject => "base:#{self}", :predicate => "rdfs:subClassOf", :object => "owl:Thing"})
+  end
+
+
+  def self.method_missing(method, *args, &block)
+    self.term.send(method, *args, &block)
+  end
+
+  def method_missing(method, *args, &block)
+    self.term.send(method, *args, &block)
+  end
+
+  def initialize(options={})
+    @uri = options[:uri] if options[:uri]
+    @uri ||= self.generate_uri
+    @term = ActiveSesame::Ontology::Term.new(@uri, self.class.repository)
+    self.add_triple({:subject => @uri, :predicate => "rdf:type", :object => self.class.uri}) if @term.relationships.size == 0
+  end
+
+  def repository
+    self.class.repository
+  end
+
+  def generate_uri
+    self.repository.base_uri + "#" + Digest::SHA1.hexdigest(Time.now.to_s + self.object_id.to_s)
+  end
+
+  @uri = "owl:Thing" #Set the default URI to the correct owl term
+
+end

data/lib/active_sesame/rdf_class.rb

@@ -0,0 +1,46 @@
+module ActiveSesame
+  #
+  # The represenation and means of exploring RDF Classes
+  #
+  class RDFClass
+
+    attr_reader :name, :properties, :subclasses, :superclass
+
+    def self.find(klass, options={})
+      @@connection ||= Repository.new
+      class_types.inject([]) {|memo, type| ResultParser.singular_values(@@connection.find_by_sparql("SELECT ?klass WHERE { ?klass rdf:type #{type} }")) }
+    end
+
+    def self.class_types
+      ["rdf:Class", "owl:Class", "owl:Thing"]
+    end
+
+    def initialize(name)
+      self.name = name
+      self.properties = find_properties
+      self.sublcasses = find_subclasses
+      self.superclass = find_superclass
+    end
+
+    def find_properties
+      ResultParser.singular_values(@@connection.find_by_sparql("SELECT ?property WHERE { #{self.name} rdf:property ?property }"))
+    end
+
+    def find_subclasses
+      ResultParser.singular_values(@@connection.find_by_sparql("SELECT ?subClasses WHERE { #{self.name} rdf:subClassOf ?subClasses }"))
+    end
+
+    def find_superclass
+      ResultParser.singular_values(@@connection.find_by_sparql("SELECT ?super WHERE { ?super rdfs:subClassOf #{self.name} }"))
+    end
+
+    def add_triple(*args)
+      if args.size == 3
+        Repository.save_triple(args[0], args[1], args[3])
+      elsif args.size == 1 and (args[0].class == Triple or args[0].class == Hash)
+        Repository.save_triple(args[0][:subject], args[0][:predicate], args[0][:object])
+      end
+    end
+  end
+end
+

data/lib/active_sesame/rdf_constants.rb

@@ -0,0 +1,55 @@
+module ActiveSesame::RDFConstants
+  def self.literal_to_proc_hash
+    {
+      "http://www.w3.org/2001/XMLSchema#string" => :to_s,
+      "http://www.w3.org/2001/XMLSchema#dateTime" => :to_time,
+      "http://www.w3.org/2001/XMLSchema#int" => :to_i
+    }
+  end
+
+  def self.literals
+    [
+     "http://www.w3.org/2001/XMLSchema#string",
+     "http://www.w3.org/2001/XMLSchema#int",
+     "http://www.w3.org/2001/XMLSchema#dateTime",
+    ]
+  end
+
+  def self.class_to_match_hash
+    {
+      String => "xsd:string",
+      Time => "xsd:dateTime",
+      Date => "xsd:date",
+      Fixnum => "xsd:integer"
+    }
+  end
+
+  def self.class_to_literal
+    {
+      String => "http://www.w3.org/2001/XMLSchema#string",
+      Time => "http://www.w3.org/2001/XMLSchema#dateTime",
+      Date => "http://www.w3.org/2001/XMLSchema#date",
+      Fixnum => "http://www.w3.org/2001/XMLSchema#int"
+    }
+  end
+
+  def self.prefixes
+    {
+      :xsd => "http://www.w3.org/2001/XMLSchema",
+      :owl => "http://www.w3.org/2002/07/owl",
+      :rdf => "http://www.w3.org/1999/02/22-rdf-syntax-ns",
+      :rdfs => "http://www.w3.org/2000/01/rdf-schema",
+    }
+  end
+
+  def self.uri_to_prefix(uri, additional_uris={})
+    uri_prefix, term = uri.split("#","")
+    uri_prefixes = self.prefixes.merge(additional_uris)
+    if term and uri_prefixes.has_key?(uri_without_pound)
+      uri_prefixes[uri_without_pound] + ":" + term
+    else
+      uri
+    end
+  end
+end
+

data/lib/active_sesame/rdf_property.rb

@@ -0,0 +1,7 @@
+module ActiveSesame
+  #
+  # The represenation and means of exploring RDF properties
+  #
+  class RDFProperty
+  end
+end

data/lib/active_sesame/repository.rb

@@ -0,0 +1,103 @@
+module ActiveSesame
+  class Repository
+
+    @@prefixes = {"xsd" => "http://www.w3.org/2001/XMLSchema#",
+      "ss" => "http://study-stash.radiology.umm.edu/ontologies/study-stash.owl",
+      "owl" => "http://www.w3.org/2002/07/owl",
+      "rdf" => "http://www.w3.org/1999/02/22-rdf-syntax-ns",
+      "rdfs" => "http://www.w3.org/2000/01/rdf-schema"}
+
+    attr_accessor :triple_store_id, :repository_uri, :repository_location, :base_uri, :connector, :prefixes
+
+    def initialize(repository_type=SesameProtocol, options={})
+      self.send(:extend, repository_type)
+      options = default_options.merge(options)
+      options.each {|key,value| send("#{key}=".to_sym, value) if respond_to?(key) }
+      self.prefixes = @@prefixes
+    end
+
+    def find_by_sparql(query, include_prefixes=true)
+      query_dispatch("", :method => :get, :body => {:query => self.sparql_base + " " + self.prefixes_to_sparql + " " + query, :queryLn => "SPARQL"})
+    end
+
+    def find(query, include_prefixes=true)
+      ActiveSesame::ResultParser.tableize(find_by_sparql(query, include_prefixes))
+    end
+
+    def group_save(xml)
+      query_dispatch("statements", {:method => :post, "content-type" => "application/x-rdftransaction", :body => xml})
+    end
+
+    def save_triple(subject, predicate, object)
+      query_dispatch("statements", {:method => :put, :body => {:subj => subject, :pred => predicate, :obj => object}})
+    end
+
+    def delete_by_pattern(subject, predicate, object)
+      query_dispatch("statements", {:method => :delete, :body => {:subj => subject, :pred => predicate, :obj => object}})
+    end
+
+    def add_prefix(prefix, uri)
+      self.prefixes = self.prefixes.merge({prefix => uri})
+    end
+
+    def add_prefixes(prefix_hash)
+      self.prefixes = self.prefixes.merge(prefix_hash)
+    end
+
+    def sparql_base
+      "BASE <#{base_uri}>"
+    end
+
+    def prefixes_to_sparql
+      self.prefixes.keys.inject("") {|sparql,key| sparql += "PREFIX #{key}: <#{self.prefixes[key]}> " }
+    end
+
+  end
+
+  module SesameProtocol
+    require 'rest-open-uri'
+    require 'uri'
+
+    def self.extended(klass)
+      simple_rest_methods :size, :contexts, :namespaces
+    end
+
+    def query_dispatch(method_name, args={})
+      args[:body][:query] = encode_sparql(args[:body][:query]) if args[:body][:query] if args[:body]
+      args[:body][:subj] = encode_sparql(args[:body][:subj]) if args[:body][:subj] if args[:body]
+      args[:body][:pred] = encode_sparql(args[:body][:pred]) if args[:body][:pred] if args[:body]
+      args[:body][:obj] = encode_sparql(args[:body][:obj]) if args[:body][:obj] if args[:body]
+      [:get, :put, :delete].include?(args[:method]) ? vars_if_get = hash_to_get(args[:body]) : vars_if_get = ""
+      method_name == "" ? slash = "" : slash = "/"
+      return open(self.repository_uri + "/" + self.triple_store_id + slash + method_name.to_s + vars_if_get, args).read
+    end
+
+    def self.simple_rest_methods(*method_names)
+      method_names.each do |name|
+        new_name = name.to_s
+        define_method(new_name) { return query_dispatch(name) }
+      end
+    end
+
+    private
+    def encode_sparql(query)
+      URI.encode(query).gsub("?","%3f").gsub("/","%2f").gsub(":","%3a").gsub("\\","5C")
+    end
+
+    def hash_to_get(hash)
+      (hash.inject("?") {|total,tuple| total += "#{tuple[0]}=#{tuple[1]}&"}).chop
+    end
+
+    def default_options
+      {
+        :repository_uri => "http://localhost:8111/sesame/repositories",
+        :triple_store_id => "test",
+        :location => "http://localhost:8111/sesame/repositories/test",
+        :query_language => "SPARQL",
+        :base_uri => "http://www.fakeontology.org/ontology.owl"
+      }
+    end
+
+  end
+
+end

data/lib/active_sesame/result_parser.rb

@@ -0,0 +1,67 @@
+module ActiveSesame
+  module ResultParser
+    require 'libxml'
+    #def ResultParser.append_features(someClass)
+    def self.tableize(xml_document)
+      xml_document = self.to_document(xml_document)
+      rows = []
+      xml_document.find("/sparql/results/result").each do |result|
+        hash = {}
+        result.each_element do |binding|
+          key = binding.attributes.to_h["name"]
+          hash[key] = value_from_binding(binding)
+        end
+        rows << hash
+      end
+      return rows
+    end
+
+      def self.singular_values(xml_document)
+        xml_document = self.to_document(xml_document)
+        values = []
+	xml_document.find("/sparql/results/result/binding").each {|binding| values << self.value_from_binding(binding) }
+	return values
+      end
+
+      def self.hash_values(xml_document)
+        xml_document = REXML::Document.new(xml_document) if xml_document.class == String
+        keys = []
+        xml_document.elements.each("/sparql/head/variable") do |variable|
+          keys << variable.attributes["name"]
+	end
+        xml_document = REXML::Document.new(xml_document) if xml_document.class == String
+        hash = {}
+	xml_document.elements.each("/sparql/results/result") do |result|
+	  hash[result.elements["binding[@name='#{keys[0]}']/uri|literal"].text] = result.elements["binding[@name='#{keys[1]}']/uri|literal"].text
+	end
+	return hash
+      end
+
+      def self.value_from_binding(binding)
+        literal = binding.find_first("literal")
+        uri = binding.find_first("uri")
+        if uri
+          uri.content
+        elsif literal
+          type_cast_literal(literal)
+        end
+      end
+
+      def self.type_cast_literal(literal_element)
+	#puts literal_element.attributes["datatype"] #Use when Exception thrown "nil is not a Symbol"
+	return literal_element.content.send(RDFConstants.literal_to_proc_hash[literal_element.attributes.to_h["datatype"]]) if literal_element.attributes.to_h["datatype"]
+	return literal_element.text
+      end
+    #end
+
+      private
+      def self.to_document(string_or_doc)
+        if string_or_doc.class == String
+          string_or_doc.sub!("xmlns=\"http://www.w3.org/2005/sparql-results#\"","")
+          LibXML::XML::Document.string(string_or_doc)
+        else
+          string_or_doc
+        end
+      end
+  end
+end

data/lib/active_sesame/support.rb

@@ -0,0 +1,114 @@
+module ActiveSesame
+  module Support
+
+    #Think about changing to a uri class rather than manipulating strings...
+    def self.property_to_constant(prop)
+      prop = prop.to_s
+      prop = ResultParser.uri_to_sym(prop) if prop.match(/#/) 
+      prop.first.upcase + prop.slice(1,prop.length)
+    end
+
+    def self.uri_to_sym(uri)
+      uri.split("#")[1].to_sym
+    end
+
+    def self.encode_whitespace(string)
+      string.gsub(" ","%20")
+    end
+
+    def self.uncode_whitespace(string)
+      return string.class == String ? string.gsub("%20"," ") : string
+    end
+
+    def is_uri?(string)
+      if string.class == String
+        string =~ /^http:\/\//
+      else
+        false
+      end
+    end
+
+    def uri_to_prefix(uri, additional_uris={})
+      uri_prefix, term = uri.split("#")
+      uri_prefixes = ActiveSesame::RDFConstants.prefixes.merge(additional_uris)
+      uri_prefixes = uri_prefixes.keys.inject(Hash.new) {|hash,key| hash[uri_prefixes[key]] = key; hash} #reverse key and value
+      #puts "\n" + uri_prefixes.inspect + "\n"
+      if uri_prefixes.has_key?(uri_prefix)
+        uri_prefixes[uri_prefix]
+      else
+        uri_prefix
+      end
+    end
+
+    def method_from_uri(uri, additional_uris={})
+      #puts "uris for doober: #{additional_uris.inspect}"
+      #puts "uri to be transformed to method #{uri}"
+      #puts "method generated: #{self.uri_to_prefix(uri, additional_uris)}"
+      uri_prefix = self.uri_to_prefix(uri, additional_uris)
+      bogus, term = uri.split("#")
+      term ? "#{uri_prefix}_#{term}" : uri_prefix
+    end
+
+    def expand_triples(triple_list, additional_uris={})
+      #puts "\n#{additional_uris.inspect}\n"
+      triple_list.collect {|triple| expand_triple(triple, additional_uris) }
+    end
+
+    def expand_triple(triple, additional_uris={})
+      #puts "\n#{additional_uris.inspect}\n"
+      triple.keys.inject(Hash.new) {|hash,key| hash[key] = expand_term(triple[key], additional_uris); hash }
+    end
+
+    def expand_terms(term_list, additional_uris={})
+      #puts "\n#{additional_uris.inspect}\n"
+      term_list.collect {|term| self.expand_term(term) }
+    end
+
+    def expand_term(full_term, additional_uris={})
+      #puts "\n#{additional_uris.inspect}\n"
+      prefix, term = full_term.split(":")
+      (term != nil and not is_uri?(full_term)) ? expand_prefix(prefix, additional_uris) + "#" + term : full_term
+    end
+
+    def expand_prefix(prefix, additional_uris={})
+      #puts "\n#{additional_uris.inspect}\n"
+      if additional_uris.has_key?(prefix)
+        additional_uris[prefix]
+      else
+        throw "Invalid Prefix: the prefix \"#{prefix}\" was not found in #{additional_uris.inspect}"
+      end
+    end
+
+  end
+
+  class Triple
+    attr_accessor :hash
+
+    def self.triple_components
+      [:subject, :object, :predicate]
+    end
+
+    def method_missing(method, *args, &block)
+      if self.hash.has_key?(method)
+        self.hash[method]
+      else
+        super(method, *args, &block)
+      end
+    end
+
+    def initialize(real_hash={})
+      self.hash = real_hash.keys.inject(Hash.new) {|hash,key| hash[key.to_sym] = real_hash[key] if self.class.triple_components.include?(key.to_sym); hash }
+      unless self.hash.has_key?(:subject) and self.hash.has_key?(:object) and self.hash.has_key?(:predicate)
+        raise "Not a valid triple: missing subject, object, or predicate"
+      end
+    end
+
+    def to_hash
+      self.hash
+    end
+
+    def to_triple
+      self
+    end
+  end
+end