talia_core 0.4.0

data/lib/talia_core/rdf_import.rb

@@ -0,0 +1,90 @@
+module TaliaCore
+  
+  
+  
+  # Import RDF data directly into the triple store.
+  # This is called to import onotologies and other RDF data.
+  class RdfImport
+    
+    class << self
+      
+      # Import the given files.
+      # The rdf_syntax may be nil. If "auto" is given, it will use a default
+      # value for each imported file
+      def import(rdf_syntax, files, context=nil)
+        puts "Importing #{files.size} files into the triple store."
+        
+        raise(ArgumentError, "Cannot use context, adapter doesn't support it.") if(context && !adapter.supports_context?)
+        
+        # check if the connection to te triplestore is ok...otherwise exit the script
+        if !adapter
+          puts "\nERROR: impossible to open a connection to the triple store. Check your system and your configuration files!\n\n"
+          exit(1)
+        end
+
+        # try to load every file into the triple store
+        files.each do |file|
+          import_file(file, rdf_syntax, context)
+        end
+
+        adapter.save if(adapter.respond_to?(:save))
+
+        puts "\n--> Importing rdf/rdfs file: complete!\n\n"
+      end
+
+      def import_file(file, syntax, context)
+        puts "\tLoading: " << file.to_s
+
+        my_context = make_ontology_context(context, file)
+
+        # load rdf/rdfs file into triplestore
+        begin
+          params = [ file ]
+          # Other than the adapter, we prefer rdfxml syntax
+          params << ((syntax && syntax != 'auto') ? syntax : 'rdfxml')
+          params << my_context if(my_context)
+          adapter.load(*params)
+        rescue Exception => e
+          puts "\tProblem loading #{file.to_s}: (#{e.message}) File not loaded!"
+          puts e.backtrace
+        end
+      end
+
+      # Clear the currently registered ontologies
+      def clear_file_contexts
+        # Remove all registered contexts
+        to_clear = Query.new(N::URI).select(:context).distinct.where(N::TALIA.rdf_context_space, N::TALIA.rdf_file_context, :context).execute
+        to_clear.each do |context|
+          adapter.clear(context) 
+        end
+        FederationManager.delete(N::TALIA.rdf_context_space, N::TALIA.rdf_file_context, nil)
+      end
+
+      private
+
+      def adapter
+        @adapter ||= ConnectionPool.write_adapter
+      end
+
+      # Prepare the context for the ontology import. All contexts will be registered
+      # to the N::TALIA.rdf_context_space resource
+      def make_ontology_context(context, file)
+        return unless(context)
+        
+        raise(ArgumentError, "Empty context") unless(context != '')
+        
+        file_context = if(context.to_s == 'auto')
+          name = URI.encode(File.basename(file, File.extname(file))).gsub(/\./, '_')
+          N::URI.new(N::TALIA + name)
+        elsif(context)
+          N::URI.new(N::TALIA + context)
+        end
+        
+        FederationManager.add(N::TALIA.rdf_context_space, N::TALIA.rdf_file_context, file_context)
+        
+        file_context
+      end
+      
+    end
+  end
+end

data/lib/talia_core/rdf_resource.rb

@@ -0,0 +1,159 @@
+module TaliaCore
+  
+  # This class encapsulates all functionality to access a specific resource
+  # in the RDF store. It is analogous to the RDFS::Resource class in ActiveRDF.
+  #
+  # However, it's specifically tailored for the use with Talia, and avoids some
+  # of the pitfalls of the original class.
+  class RdfResource
+
+    include RDFS::ResourceLike
+    
+    class << self
+      
+      # A list of "default" types that will be added to all resources
+      def default_types
+        @default_types ||= [
+          N::SourceClass.new(N::RDFS.Resource)
+        ]
+      end
+      
+    end
+    
+    # The class of objects that will be "produced" by this RdfResource
+    attr_writer :object_class
+    
+    def object_class
+      @object_class ||= TaliaCore::Source
+    end
+    
+    # Initialize a new resource with the given URI
+    def initialize(uri)
+      @uri = N::URI.new(uri)
+    end
+
+    # Direct writing of a predicate, with having to fetch a list first
+    def direct_write_predicate(predicate, value)
+      FederationManager.add(self, predicate, value)
+    end
+
+    # Clears all rdf for this resource. FIXME: Not context-aware.
+    def clear_rdf
+      FederationManager.delete_all(self)
+    end
+
+    # Removes the given predicate (restrict to the triple with the
+    # given value if a value is given).
+    def remove(predicate, value = nil)
+      FederationManager.delete(self, predicate, value)
+    end
+
+    # Returns the value(s) of the given predicates as a PropertyList filled
+    # with the defined object_class objects.
+    def [](predicate)
+      predicate = N::URI.new(predicate) unless(predicate.kind_of?(N::URI))
+      
+      property_list = Query.new(object_class).distinct(:o).where(self, predicate, :o).execute
+      
+      PropertyList.new(predicate, property_list, self, source_exists?)
+    end
+    
+    # Returns an on-the-fly object that can be used to query for "inverse"
+    # properties of this resource (meaning triples that have the current 
+    # resource as an object.) 
+    #
+    # The returned object will respond to a [] (array accessor) call which 
+    # allows the user to specify the predicate to use.
+    #
+    # Example: <tt>resource.inverse[N::DNCS::title]</tt>
+    #
+    # The [] method will return a list of objects that are instances of object_class
+    def inverse
+      inverseobj = Object.new
+      inverseobj.instance_variable_set(:@obj_uri, self)
+      inverseobj.instance_variable_set(:@obj_class, object_class)
+      
+      class <<inverseobj     
+        
+        def [](property)
+          property = N::URI.new(property) unless(property.kind_of?(N::URI))
+          Query.new(@obj_class).distinct(:s).where(:s, property, @obj_uri).execute
+        end
+        private(:type)
+      end
+      
+      return inverseobj
+    end
+    
+    
+    # Returns the uri of this resource as a string
+    def uri
+      @uri.to_s
+    end
+    
+    # Returns the predicates that are directly defined for this resource
+    def direct_predicates
+      Query.new(N::Predicate).distinct(:p).where(self, :p, :o).execute
+    end
+    
+    # Returns the "inverse" predicates for the resource. these are the predicates
+    # for which this resource exists as an object
+    def inverse_predicates
+      qry = Query.new.distinct.select(:p)
+      qry.where(:s, :p, N::URI.new(uri.to_s))
+      qry.execute.collect{ |res| N::Predicate.new(res.uri) }
+    end
+    
+    # Saves the current resource and it's properties to the RDF. (This has
+    # been optimized so that if only one RDF backend is present it won't do
+    # any copying around.
+    def save
+      if((ConnectionPool.read_adapters.size == 1) &&
+            (ConnectionPool.write_adapter == ConnectionPool.read_adapters.first))
+        save_default_types # Only write the "default" types to the store
+      else
+        full_save # Do the full save operation
+      end
+    end
+    
+    # Returns the types of this resource as N::SourceClass objects
+    def types
+      types = Query.new(N::SourceClass).distinct(:t).where(self,N::RDF::type,:t).execute
+      # Add the "default" types if necessary
+      self.class.default_types.each do |def_type|
+        types << def_type unless(types.include?(def_type))
+      end
+      
+      # Make a property list for the types.
+      PropertyList.new(N::RDF::type, types, self, source_exists?)
+    end
+    
+    private
+    
+    # Saves the the "default" types of this resource to the writing adapter
+    def save_default_types
+      self.class.default_types.each do |t|
+        FederationManager.add(self, N::RDF::type, t)
+      end
+    end
+    
+    # "Full" save which reads the triples from all adapters, and saves them
+    # the writing adapter. This operation can be very slow.
+    def full_save
+      types.each do |t|
+        FederationManager.add(self, N::RDF::type, t)
+      end
+
+      Query.new(N::URI).distinct(:p,:o).where(self, :p, :o).execute do |p, o|
+        FederationManager.add(self, p, o)
+      end
+    end
+    
+    # Returns true if the corresponding Source already exists in the database
+    def source_exists?
+      # FIXME: Just a helper as long as ActiveSource is not completely integrated!
+      Source.exists?(@uri) || ActiveSource.exists?(:uri => @uri.to_s)
+    end
+    
+  end
+end

data/lib/talia_core/semantic_collection_item.rb

@@ -0,0 +1,93 @@
+module TaliaCore
+
+  # This is a single item in a semantic collection wrapper. The contents are
+  #  * fat_relation - a SemanticRelation with all the columns needed to build the
+  #    related objects
+  #  * plain_relation - a normal semantic relation object (either this or fat_relation)
+  #    should be given
+  # Only one of the above should be usually given
+  class SemanticCollectionItem
+
+    attr_reader :plain_relation, :fat_relation
+
+    def initialize(relation, plain_or_fat)
+      case plain_or_fat
+      when :plain
+        @plain_relation = relation
+      when :fat
+        @fat_relation = relation
+      else
+        raise(ArgumentError, "Unknown type")
+      end
+      @object_type = SemanticCollectionWrapper.special_types[relation.predicate_uri.to_s]
+    end
+
+    # Return the relation object that was given
+    def relation
+      @fat_relation || @plain_relation
+    end
+
+    # Return the "value" (Semantic relation value or the related ActiveSource)
+    def value
+      semprop = object.is_a?(SemanticProperty)
+      if(@object_type)
+        assit(object, "Must have object for #{relation.predicate_uri}")
+        raise(ArgumentError, 'Must not have a property for a typed item') if(semprop)
+        @object_type.new(object.uri.to_s)
+      else
+        # Plain, return the object or the value for SemanticProperties
+        semprop ? object.value : object
+      end
+    end
+
+    # Creates an object from the given relation
+    def object
+      @object ||= begin
+        if(@fat_relation)
+          create_object_from(@fat_relation)
+        elsif(@plain_relation)
+          @plain_relation.object
+        else
+          raise(ArgumentError, "No relation was given to this object")
+        end
+      end
+    end
+
+    def ==(compare)
+      self.value == compare
+    end
+
+    # if the object is a relation, it will r
+
+    # Creates an object frm the given "fat" relation. This retrieves the data
+    # from the relation object and instantiates it just like it would be after
+    # a find operation.
+    def create_object_from(fat_relation)
+      # First we find out which class (table our target object is in)
+      klass = fat_relation.object_type.constantize
+      record = nil
+      if(klass == TaliaCore::ActiveSource)
+        # We prepare a hash of properties for the ActiveSource
+        record = {
+          'uri' => fat_relation.object_uri,
+          'created_at' => fat_relation.object_created_at,
+          'updated_at' => fat_relation.object_updated_at,
+          'type' => fat_relation.object_realtype
+        }
+      elsif(klass == TaliaCore::SemanticProperty)
+        # We prepare a hash of properties for the SemanticProperty
+        record = {
+          'value' => fat_relation.property_value,
+          'created_at' => fat_relation.property_created_at,
+          'updated_at' => fat_relation.property_updated_at
+        }
+      end
+      # Common attributes
+      record['id'] = fat_relation.object_id
+      # Instantiate the new record
+      klass.send(:instantiate, record)
+    end
+
+  end
+
+end

data/lib/talia_core/semantic_collection_wrapper.rb

@@ -0,0 +1,324 @@
+module TaliaCore
+  
+  # Wraps the Array/Collection returned from the ActiveRecord, simply 
+  # "hiding" the SemanticProperty objects behind strings.
+  class SemanticCollectionWrapper
+
+    include Enumerable
+
+    attr_reader :force_type
+
+    # Simple hash that checks if a type if property requires "special" handling
+    # This will cause the wrapper to accept ActiveSource relations and all
+    # sources will be casted to the given type
+    def self.special_types
+      @special_types ||= {
+        N::RDF.type.to_s => N::SourceClass
+      }
+    end
+
+    # Initialize the list
+    def initialize(source, predicate)
+      # raise(ActiveRecord::RecordNotSaved, "No properties on unsaved record.") if(source.new_record?)
+      @assoc_source = source
+      @assoc_predicate = if(predicate.respond_to?(:uri))
+        predicate.uri.to_s
+      else
+        predicate.to_s
+      end
+      @force_type = self.class.special_types[@assoc_predicate]
+    end
+
+    # Get the element '''value''' at the given index
+    def at(index)
+      items.at(index).value if(items.at(index))
+    end
+    alias :[] :at
+
+    def first
+      item = items.first
+      item ? item.value : nil
+    end
+
+    def last
+      item = items.last
+      item ? item.value : nil
+    end
+
+    # Gets the value at the given index
+    def get_item_at(index)
+      items.at(index).object if(items.at(index))
+    end
+
+    # Iterates over each '''value''' of the items in the relation.
+    def each
+      items.each { |item| yield(item.value) }
+    end
+
+    # Collect method for the semantic wrapper
+    def collect
+      items.collect { |item| yield(item.value) }
+    end
+
+    # Iterates of each '''target''' of the items in the relation. (This
+    # will pass in SemanticProperty objects instead of the value
+    def each_item
+      items.each { |item| yield(item.object) }
+    end
+
+    # Returns an array with all values in the collection
+    def values
+      items.collect { |item| item.value }
+    end
+
+    # Size of the collection.
+    def size
+      return items.size if(loaded?)
+      if(@items)
+        # This is not really possible without loading, so we do it
+        load!
+        items.size
+      else
+        SemanticRelation.count(:conditions => {
+            'subject_id' => @assoc_source.id,
+            'predicate_uri' => @assoc_predicate })
+      end
+    end
+
+    # Joins the elments into a string
+    def join(join_str = ', ')
+      strs = items.collect { |item| item.value.to_s }
+      strs.join(join_str)
+    end
+
+    # Index of the given value
+    def index(value)
+      items.index(value)
+    end
+
+    # Check if the collection includes the value
+    def include?(value)
+      items.include?(value)
+    end
+
+    # Get the index of the given item
+  
+    # Push to collection. Giving a string will create a property to be created,
+    # saved and associated.
+    def <<(value)
+      add_with_order(value, nil)
+    end
+    alias_method :concat, '<<'
+    
+    # Adds the object and gives the relation the given order. 
+    def add_with_order(value, order)
+      # We use order exclusively for "ordering" predicates
+      assit_equal(TaliaCore::OrderedSource.index_to_predicate(order), @assoc_predicate) if(order)
+      raise(ArgumentError, "cannot add nil") unless(value != nil)
+      if(value.kind_of?(Array))
+        value.each { |v| add_record_for(v, order) }
+      else
+        add_record_for(value, order)
+      end
+    end
+    
+    # Replace a value with a new one
+    def replace(old_value, new_value)
+      idx = items.index(old_value)
+      items[idx].destroy
+      add_record_for(new_value) { |new_item| items[idx] = new_item }
+    end
+    
+    # Remove the given value. With no parameters, the whole list will be
+    # cleared and the RDF will be updated immediately.
+    def remove(*params)
+      if(params.length > 0)
+        params.each { |par| remove_relation(par) }
+      else
+        if(loaded?)
+          items.each { |item| item.relation.destroy }
+        else
+          SemanticRelation.destroy_all(
+            :subject_id => @assoc_source.id,
+            :predicate_uri => @assoc_predicate
+          )
+        end
+        @assoc_source.my_rdf.remove(N::URI.new(@assoc_predicate))
+        @items = []
+        @loaded = true
+      end
+    end
+
+    # This attempts to save the items to the database
+    def save_items!
+      return if(clean?) # If there are no items, nothing was modified
+      @assoc_source.save! unless(@assoc_source.id)
+      @items.each do |item|
+        next if(item.fat_relation) # we skip the fat relations, they are never new and never saveable
+        rel = item.plain_relation
+        must_save = rel.new_record?
+        if(rel.object_id.nil?)
+          rel.object.save! if(rel.object.new_record?)
+          rel.object_id = rel.object.id
+          must_save = true
+        end
+        unless(rel.subject_id != nil)
+          rel.subject_id = @assoc_source.id
+          must_save = true
+        end
+        rel.save! if(must_save)
+      end
+      @items = nil unless(loaded?) # Otherwise we'll have trouble reload-and merging
+    end
+
+    # Indicates of the internal collection is loaded
+    def loaded?
+      @loaded
+    end
+
+    # Indicates that the wraper is "clean", that is it hasn't been written to
+    # or read from
+    def clean?
+      @items.nil?
+    end
+
+    def empty?
+      self.size == 0
+    end
+
+    # Injector for a fat relation. This must take place before flagging the
+    # source as "loaded"
+    def inject_fat_item(fat_rel)
+      raise(RuntimeError, 'Trying to inject in loaded object.') if(loaded?)
+      @items ||= []
+      @items << SemanticCollectionItem.new(fat_rel, :fat)
+    end
+
+    private
+
+    # Load the current relation. (Loading should be lazy, so that the database
+    # is not hit until needed.
+    def load!
+      # The "fat" relations contain all the data to build the related objects if
+      # required
+      relations = SemanticRelation.find_fat_relations(@assoc_source, @assoc_predicate)
+
+      init_from_fat_rels(relations)
+    end
+
+    # Inject a fat relation into the items
+
+
+    # Inititlizes the collection from the given collection of "fat" relations
+    def init_from_fat_rels(fat_relations)
+      # Check if there are records that have been added previously
+      old_items = @items
+      # Create the internal collection
+      @items = Array.new(fat_relations.size)
+      fat_relations.each_index do |idx|
+        rel = SemanticCollectionItem.new(fat_relations.at(idx), :fat)
+        @items[idx] = rel
+      end
+      @items = (@items | old_items) if(old_items)
+      @loaded = true
+      @items
+    end
+
+    # Returns the items in the collection
+    def items
+      load! unless(loaded?)
+      @items
+    end
+
+    # Deletes the relation where with the current predicate and the given 
+    # value.
+    def remove_relation(value)
+      idx = items.index(value)
+      return unless(idx)
+      remove_at(idx)
+    end
+
+    # Removes a relation at the given index
+    def remove_at(index)
+      items.at(index).relation.destroy
+      items.delete_at(index)
+    end
+
+    # Creates a record for a value and adds it. This will add the given value if it's 
+    # a database record and otherwise create a property with the given value.
+    # The block can be given when you want to add the new SemanticCollectionItem
+    # to the colleciton in a specific way.
+    # are loaded.
+    def add_record_for(value, order = nil)
+      if(@force_type)
+        # If we have a type, we must transform the value
+        value = value.respond_to?(:uri) ? value.uri : value
+        value = ActiveSource.new(value.to_s)
+      end
+
+      value = check_for_source(value) if(value.is_a?(ActiveSource))
+
+      rel = create_predicate(value)
+      rel.rel_order = order if(order)
+      item = SemanticCollectionItem.new(rel, :plain)
+      block_given? ? yield(item) : insert_item(item)
+    end
+
+    # Insert a new item
+    def insert_item(item)
+      @items ||= []
+      @items << item
+    end
+
+    # Write a triple to the store. For normal operation it's recommended that
+    # the usual accessor methods are used. This method does less checking
+    # and does not accept array objects as value.
+    def create_predicate(value)
+      # TODO: Semantic Properties should only be created inside, since assigning
+      #       one to multiple relations and then deleting breaks integrity.
+      #       The whole semantic property should be flattened into a field in
+      #       SemanticRelation anyway.
+      assit(!value.is_a?(SemanticProperty), "Should not pass in Semantic Properties here!")
+      # We need to manually create the relation, to add the predicate_url
+      to_add = SemanticRelation.new(
+        :subject_id => @assoc_source.id,
+        :predicate_uri => @assoc_predicate
+      ) # Create a new relation linked to this object
+
+      if(value.is_a?(TaliaCore::ActiveSource) || value.is_a?(TaliaCore::SemanticProperty))
+        to_add.object = value
+      else
+        prop = TaliaCore::SemanticProperty.new
+        prop.value = value
+        to_add.object = prop
+      end
+      to_add
+    end
+
+
+
+    # This "checks" for the given source. If a source with the same URI has been
+    # added to any collection wrapper unsaved
+    def check_for_source(source)
+      return source unless(source.new_record?)
+      cached = unsaved_source_cache[source.uri.to_s]
+      if(cached.nil?)
+        unsaved_source_cache[source.uri.to_s] = source
+        cached = source
+      end
+      cached
+    end
+
+    # Cache for sources that were added as unsaved elements
+    def self.unsaved_source_cache
+      @unsaved_source_cache ||= {}
+    end
+
+    def unsaved_source_cache
+      SemanticCollectionWrapper.unsaved_source_cache
+    end
+
+
+  end
+  
+end

data/lib/talia_core/semantic_property.rb

@@ -0,0 +1,7 @@
+module TaliaCore
+  
+  class SemanticProperty < ActiveRecord::Base
+    validates_presence_of :value
+  end
+  
+end