activesesame 0.1.0

data/README.txt

@@ -0,0 +1,25 @@
+See the wiki for details:
+http://wiki.github.com/mwarnock/activesesame
+
+(The MIT License)
+
+Copyright (c) 2008 ActiveSesame
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,3 @@
+require 'rake'
+
+Dir['tasks/*.rake'].each { |rake| load rake }

data/lib/active_sesame/active_sesame.rb

@@ -0,0 +1,7 @@
+module ActiveSesame
+  #defined?("ACTIVE_SESAME_ROOT") ? path = ACTIVE_SEASAME_ROOT : 
+  path = File.dirname(__FILE__)
+  %w(monkey_patches rdf_constants result_parser support repository transaction_builder ontology base behaviors owl_thing).each do |f|
+    require File.join(path, f)
+  end
+end

data/lib/active_sesame/base.rb

@@ -0,0 +1,235 @@
+module ActiveSesame
+class Base
+  ActiveSesame::MonkeyPatches #Run The monkey Patches
+  
+  def Base.inherited(subClass)
+    ############################################
+    #######  Generic Attribute Handling ########
+    ############################################
+
+    #Create class variables that are independant of the super class
+    class << self
+      attr_accessor :rdf_class, :triple_store_id, :base_uri, :unique_property, :unique_property_type, :attributes, :attribute_method_names
+      attr_accessor :connection
+      attr_accessor :simple_attributes, :simple_method_names
+      attr_accessor :complex_attributes, :complex_method_names
+    end
+
+    #Set the Default values for the inheritable class accessors
+    subClass.rdf_class = subClass.name.split("::").last.to_s
+    subClass.triple_store_id = "study-stash"
+    subClass.set_base_uri "http://study-stash.radiology.umm.edu/ontologies/study-stash.owl#"
+    subClass.unique_property = subClass.name
+    subClass.unique_property_type = RDFConstants.class_to_match_hash[String]
+    subClass.attributes = {}
+    subClass.attribute_method_names = []
+    subClass.simple_attributes = {}
+    subClass.simple_method_names = []
+    subClass.complex_attributes = {}
+    subClass.complex_method_names = []
+    subClass.connection = Repository.new
+
+    #Create the attribute accessors for instances
+    attr_accessor :attribute_table, :instance, :transaction_triples
+
+    def subClass.base_uri_location
+      uri_with_quacks = self.base_uri.split(" ").last
+      uri_with_quacks.slice(1,uri_with_quacks.length-2)
+    end
+
+    def subClass.set_rdf_class(new_class_name)
+      self.rdf_class = new_class_name.to_s
+      self.set_attributes
+    end
+
+    def subClass.set_triple_store_id(new_id)
+      self.triple_store_id = new_id.to_s
+      self.set_attributes
+    end
+
+    def subClass.set_unique_property(new_property_name, type)
+      self.unique_property = new_property_name.to_s
+      self.unique_property_type = RDFConstants.class_to_match_hash[type]
+    end
+
+    def subClass.set_attributes
+      #puts "SELECT ?property_name ?property_type WHERE { ?property_name rdfs:domain <#{rdf_class}>; rdfs:range ?property_type }"
+      self.attributes = ResultParser.hash_values(self.connection.find_by_sparql("SELECT ?property_name ?property_type WHERE { ?property_name rdfs:domain <#{rdf_class}>; rdfs:range ?property_type }"))
+      self.attributes.each do |uri,type|
+        if RDFConstants.literals.include?(type) 
+          self.simple_attributes[uri] = type
+          self.simple_method_names << Support.uri_to_sym(uri)
+        else
+          self.complex_attributes[uri] = type
+          self.complex_method_names << Support.uri_to_sym(uri).to_s.pluralize
+        end
+      end
+      self.generate_methods
+      self.attributes
+    end
+      
+    def subClass.set_attribute_method_names
+      self.attribute_method_names = self.attributes.keys.collect {|key| Support.uri_to_sym(key) }
+    end
+
+    ####################################
+    ######## Validation Tools  #########
+    ####################################
+
+    def subClass.validate(instance)
+      self.find(instance.instance) ? false : true
+    end
+
+    ###########################################
+    ######## Dynamic Method Generation ########
+    ###########################################
+
+    #creates accessor methods and initiates other method Generators
+    def subClass.generate_methods
+      attr_accessor *(self.simple_method_names) unless self.simple_method_names.empty?
+      self.generate_find_methods
+      self.generate_complex_methods
+    end
+
+    #Generates methods for selecting all the uri (complex) properties associated with a specific instance
+    def subClass.generate_complex_methods
+      self.complex_attributes.each do |uri,type|
+        method = Support.uri_to_sym(uri)
+        define_method(method.to_s.pluralize) do
+          if Kernel.const_get(Support.uri_to_sym(type))
+            ResultParser.singular_values(self.class.find_by_sparql("SELECT ?object WHERE { <#{self.instance}> <#{uri}> ?object }")).collect {|foreign_uri| Kernel.const_get(Support.uri_to_sym(type)).find(foreign_uri) }
+          else
+            "No Class Defined for: #{Support.uri_to_sym(type)}"
+          end
+        end
+        define_method("add_" + method.to_s.pluralize) do |instance_or_object|
+          instance_or_object.class == String ? instance = instance_or_object : instance = instance_or_object.instance
+          if Kernel.const_get(Support.uri_to_sym(type))
+            self.class.group_save(ActiveSesame::TransactionBuilder.build_triple(self.instance, uri, instance))
+          end
+        end
+        attr_accessor (method.to_s.pluralize + "_for_" + self.name.downcase).to_sym
+      end
+    end
+
+    #Generates all the find_by_property methods for the inherited class
+    def subClass.generate_find_methods
+      self.simple_method_names.each do |m|
+        self.class_eval(
+          "def self.find_by_#{m} (value)
+          #puts \"SELECT \#{self.attributes_to_sparql_vars} WHERE { ?instance <#{m}> '\#{value}'^^\#{ActiveSesame::RDFConstants.class_to_match_hash[value.class]} . \#{self.attributes_to_sparql_patterns}}\"
+               self.new(ResultParser.tableize(self.connection.find_by_sparql(\"SELECT \#{self.attributes_to_sparql_vars} WHERE { ?instance <#{m}> '\#{value}' . \#{self.attributes_to_sparql_patterns}}\")).first)
+               #puts self.connection.find_by_sparql(\"SELECT \#{self.attributes_to_sparql_vars} WHERE { ?instance <#{m}> '\#{value}'^^\#{ActiveSesame::RDFConstants.class_to_match_hash[value.class]} . \#{self.attributes_to_sparql_patterns}}\")
+	     end") #When you fix the datatype attributes in allegro graph you need to change this function or you'll get nils
+      end
+    end
+
+
+    ######################################
+    ######## SPARQL Query Helpers ########
+    ######################################
+
+    #Converts the simple method names list into a series of sparql patterns for the WHERE clause
+    def subClass.attributes_to_sparql_patterns
+      self.simple_method_names.inject("") {|outstring,item| outstring += "?instance <#{item}> ?#{item}. "}
+    end
+
+    #Converts the simple method names list into a string of SPARQL variables
+    def subClass.attributes_to_sparql_vars
+      "?instance ?" + self.simple_method_names.join(" ?")
+    end
+
+
+    ######################################
+    ######### SPARQL Find Methods ########
+    ######################################
+
+    #Does a SPARQL select based on simple options and instantiates the Class Instances From the Returning XML
+    def subClass.find(unique_uri_or_length, args={})
+      if unique_uri_or_length.class != Symbol
+        begin
+          puts "SELECT #{self.attributes_to_sparql_vars.gsub("?instance","")} WHERE { #{self.attributes_to_sparql_patterns.gsub("?instance",'<' + unique_uri_or_length + '>')}}"
+          graph_object = self.new(ResultParser.tableize(self.connection.find_by_sparql("SELECT #{self.attributes_to_sparql_vars.gsub("?instance","")} WHERE { #{self.attributes_to_sparql_patterns.gsub("?instance",'<' + unique_uri_or_length + '>')}}")).first)
+          graph_object.instance = unique_uri_or_length
+          return graph_object
+        rescue
+          return nil
+        end
+      elsif args.has_key?(:sparql) #Submit Pure Sparql without Object Creation (Returns Hash)
+        (ResultParser.tableize(self.connection.find_by_sparql(:sparql)))
+      elsif args.has_key?(:simple_conditional) #Returns objects that match the simple_condition, if specified, and apply the length operator via the send method
+        (ResultParser.tableize(self.connection.find_by_sparql("SELECT #{self.attributes_to_sparql_vars} WHERE {?instance rdf:type <#{self.rdf_class}> . #{args[:simple_conditional]} OPTIONAL {#{self.attributes_to_sparql_patterns}} . }")).collect {|table| self.new(table)}).send(unique_uri_or_length)
+      else
+        (ResultParser.tableize(self.connection.find_by_sparql("SELECT #{self.attributes_to_sparql_vars} WHERE {?instance rdf:type <#{self.rdf_class}> . OPTIONAL {#{self.attributes_to_sparql_patterns}} . }")).collect {|table| self.new(table)}).send(unique_uri_or_length)
+      end
+    end
+
+    def subClass.uniques(args={})
+      uniques = []
+      generals = self.find(:all, args)
+      generals.each {|g| uniques << g unless uniques.find {|u| u.instance == g.instance}}
+      uniques
+    end
+
+    #########################################
+    ########## Class Admin Methods ##########
+    #########################################
+
+
+    #########################################
+    ######## Class Initializer Calls ########
+    #########################################
+    subClass.set_attributes
+    subClass.set_attribute_method_names
+  end
+    
+  #Class methods for ActiveSesame::Base
+  #These will not be inherited by sub classes
+  class << self
+  end
+
+  ######################################
+  ########## Instance Methods ##########
+  ######################################
+    
+  def initialize(attributes_table={})
+    @attribute_table = attributes_table
+    @attribute_table.each {|key,value| self.send(key.to_s + "=", ActiveSesame::Support.uncode_whitespace(value)) }
+  end
+    
+  def add_transaction_triple(s,p,o)
+    self.transaction_triples = self.transaction_triples + ActiveSesame::TransactionBuilder.build_triple(s,p,o)
+  end
+
+  def save
+    if self.class.validate(self)
+      self.build_triples
+      self.before_save
+      self.class.group_save(self.transaction_triples)
+      self.after_save
+      return true
+    else
+      self.after_save
+      return false
+    end
+  end
+
+  def build_triples
+    self.transaction_triples = ActiveSesame::TransactionBuilder.object_to_triples(self)
+  end
+
+  def before_save
+  end
+
+  def after_save
+    self.class.complex_method_names.each do |method|
+      values = self.send(method.to_s.pluralize + "_for_" + self.class.rdf_class.downcase)
+      values.to_a
+      if self.send(method.to_s.pluralize + "_for_" + self.class.rdf_class.downcase)
+        values.each {|value| self.send("add_" + method.to_s.pluralize, value)}
+      end
+    end
+  end
+
+end
+end

data/lib/active_sesame/behaviors.rb

@@ -0,0 +1,38 @@
+module ActiveSesame::Behaviors
+
+  module Ontology
+
+    def self.mimic(klass, options={})
+      defaults = {:repository => ActiveSesame::Repository.new, :ontology_attribute => :name}
+      defaults.merge!(options)
+      klass.send(:include, self)
+      klass.repository = defaults[:repository]
+      klass.ontology_attribute = defaults[:ontology_attribute]
+      return klass
+    end
+
+    def self.included(klass)
+      class << klass
+        attr_accessor :ontology_attribute, :repository
+      end
+
+      klass.ontology_attribute = :name
+      klass.repository =  ActiveSesame::Repository.new
+      klass.class_eval do
+        def self.set_ontology_attribute(value,&block)
+          block_given? ? attribute_value = yield(value) : attribute_value = value
+          self.ontology_attribute = value.to_sym
+        end
+
+        def self.set_repository(repository)
+          self.repository = repository
+        end
+      end
+    end
+
+    def ontology
+      @ontology ||= ActiveSesame::Ontology::Term.new(self.send(self.class.ontology_attribute), self.class.repository)
+    end
+  end
+
+end

data/lib/active_sesame/general.rb

@@ -0,0 +1,25 @@
+require 'active_support'
+require 'active_sesame'
+class Study < ActiveSesame::Base
+end
+
+@study_hash = {}
+Study.simple_method_names.each {|key| @study_hash[key] = "" }
+@study_hash[:patientSex] = "M"
+@study_hash[:procedureCode] = "A CT of the Head"
+@study_hash[:aquiringModality] = "CT"
+@study_hash[:patientAge] = "015Y"
+@study_hash[:patientHistory] = "Cronic Headaches"
+@study_hash[:accessionNumber] = "0523432"
+@study_hash[:studyDateTime] = "2007-08-11 13:02"
+@study_hash[:bodyPartExamined] = "Head"
+@study_hash[:patientID] = "101"
+@study_hash[:reasonFor] = "Cronic Headaches"
+@study_hash[:submittedBy] = "mwarnock"
+@study_hash[:patientName] = "John Doe"
+@study_hash[:uid] = "1.2.34.53534.32342342.9885"
+@study_hash[:instance] = Study.base_uri_location + @study_hash[:uid].gsub(".","_")
+@study = Study.new(@study_hash)
+@study.save
+
+puts Study.find(:all).inspect

data/lib/active_sesame/monkey_patches.rb

@@ -0,0 +1,15 @@
+module ActiveSesame
+  module MonkeyPatches
+    Array.class_eval do
+      def all
+        self
+      end
+    end
+
+    Hash.class_eval do
+      def to_triple
+        ActiveSesame::Triple.new(self)
+      end
+    end
+  end
+end

data/lib/active_sesame/ontology.rb

@@ -0,0 +1,93 @@
+module ActiveSesame::Ontology
+  class Term
+
+    class << self
+      attr_accessor :repository
+    end
+
+    attr_reader :relationships, :relationship_map, :term_type, :term, :unsaved_triples
+    extend ActiveSesame::Support
+
+    def method_missing(method, *args, &block)
+      if @relationships.has_key?(method.to_s)
+        if @relationships[method].class == Term
+          @relationships[method]
+        else
+          @relationships[method] = Term.new(@relationships[method.to_s])
+        end
+      else
+        super(method, *args, &block)
+      end
+    end
+
+    def initialize(ontoterm, repo = ActiveSesame::Repository.new)
+      self.class.repository = repo
+      @term = ontoterm
+      @unsaved_triples = []
+      set_relationships
+    end
+
+    def reset
+      @relationships = {}
+      @relationship_map = nil
+      set_relationships
+      true
+    end
+
+    def to_triples
+      self.relationship_map.collect do |po_hash|
+        ActiveSesame::Triple.new({:subject => self.term, :predicate => po_hash["predicate"], :object => po_hash["object"]})
+      end
+    end
+
+    def add_relationship(triple)
+      triple[:subject] = self.term unless triple.class == ActiveSesame::Triple and not (triple.has_key?[:subject] or triple.has_key?["subject"])
+      triple = triple.to_triple
+      key = self.class.method_from_uri(triple.predicate, "base" => self.class.repository.base_uri) #This is using rdf constants
+      if not self.relationships.has_key?(key)
+        self.relationships[key] = triple.object
+      elsif self.relationships[key].class != Array
+        self.relationships[key] = [self.relationships[key], triple.object]
+      else
+        self.relationships[key] << triple.object
+      end
+    end
+
+    def add_triple(triple)
+      expanded_triple = self.class.expand_triple(triple, self.class.repository.prefixes.merge({"base" => self.class.repository.base_uri}))
+      self.unsaved_triples << expanded_triple
+      self.add_relationship(expanded_triple)
+    end
+
+
+    def save
+      success = self.class.repository.group_save(self.transactions)
+      if success
+        @unsaved_triples = []
+        success
+      else
+        success
+      end
+    end
+
+    def transactions
+      ActiveSesame::TransactionBuilder.build_triples(self.unsaved_triples)
+    end
+
+    private
+    def set_relationships
+      @term = self.class.expand_term(@term, self.class.repository.prefixes.merge({"base" => self.class.repository.base_uri}))
+      if self.class.is_uri?(@term)
+        @term_type = "uri"
+        @relationship_map ||= self.class.repository.find("SELECT ?predicate ?object WHERE { <#{@term}> ?predicate ?object }")
+        @relationships = {}
+        self.relationship_map.each {|map| self.add_relationship(map) }
+      else
+        @term_type = "literal"
+      end
+    end
+
+
+  end
+
+end