talia_core 0.5.0 → 0.5.1

data/VERSION.yml

@@ -1,5 +1,5 @@
 --- 
 :major: 0
 :minor: 5
-:patch: 0
+:patch: 1
 :build: 

data/config/talia_core.yml

@@ -16,6 +16,8 @@ namespaces:
   talias: http://trac.talia.discovery-project.eu/wiki/StructuralOntology#
   taliadom: http://trac.talia.discovery-project.eu/wiki/SampleDomainOntology#
   sesame: http://www.openrdf.org/schema/sesame#
+  swicky: http://discovery-project.eu/ontologies/philoSpace/
+  discovery: http://discovery-project.eu/ontologies/scholar/0.1/
 site_name: Talia Test
 iip_server_uri: http://localhost:80/fcgi-bin/iipsrv.fcgi
 vips_command: /opt/local/vips

data/config/talia_core.yml.example

@@ -44,4 +44,6 @@ namespaces:
     luccadom: http://trac.talia.discovery-project.eu/wiki/LuccaOntology#
     talias: http://trac.talia.discovery-project.eu/wiki/StructuralOntology#
     taliadom: http://trac.talia.discovery-project.eu/wiki/SampleDomainOntology#
-    sesame: http://www.openrdf.org/schema/sesame#
+    sesame: http://www.openrdf.org/schema/sesame#
+    swicky: http://discovery-project.eu/ontologies/philoSpace/
+    discovery: http://discovery-project.eu/ontologies/scholar/0.1/

data/generators/talia_base/templates/app/controllers/ontologies_controller.rb

@@ -1,13 +1,13 @@
 class OntologiesController < ApplicationController
   
     def index
-      onto_qry =  Query.new(N::URI).select(:context).distinct.where(N::TALIA.rdf_context_space, N::TALIA.rdf_file_context, :context)
+      onto_qry =  ActiveRDF::Query.new(N::URI).select(:context).distinct.where(N::TALIA.rdf_context_space, N::TALIA.rdf_file_context, :context)
       @ontologies = onto_qry.execute.collect { |context| context.local_name }
     end
     
     def show
       ontology_url = N::TALIA + URI.encode(params[:id])
-      @triples = Query.new(N::URI).select(:s, :p, :o).where(:s, :p, :o, ontology_url).execute
+      @triples = ActiveRDF::Query.new(N::URI).select(:s, :p, :o).where(:s, :p, :o, ontology_url).execute
     end
     
 end

data/generators/talia_base/templates/app/controllers/sources_controller.rb

@@ -158,7 +158,7 @@ class SourcesController < ApplicationController
 
     def source_types
       return @source_types if(@source_types)
-      @source_types = Query.new(N::URI).select(:type).distinct.where(:source, N::RDF.type, :type).execute
+      @source_types = ActiveRDF::Query.new(N::URI).select(:type).distinct.where(:source, N::RDF.type, :type).execute
       @source_types
     end
 

data/lib/swicky/api_result.rb

@@ -0,0 +1,57 @@
+require 'builder'
+
+module Swicky
+  
+  # Helper class to encode API result codes for the controller
+  class ApiResult
+    
+    attr_accessor :result, :message
+    RESULTS = {
+      :success => 200,
+      :illegal_parameter => 400,
+      :error => 500
+    }
+    
+    def initialize(result, message)
+      raise(ArgumentError, "Illegal Result #{result}") unless(RESULTS.keys.include?(result.to_sym))
+      @result = result.to_sym
+      @message = message
+    end
+    
+    def http_status
+      RESULTS[result]
+    end
+    
+    def to_xml
+      xml = ''
+      builder = Builder::XmlMarkup.new(:target => xml, :indent => 2)
+      builder.instruct!
+      builder.swicky_api do
+        builder.result(result.to_s)
+        builder.message(message)
+      end
+      xml
+    end
+    
+    def to_json
+      { :result => result, :message => message }.to_json
+    end
+    
+    def to_html
+      html = ''
+      builder = Builder::XmlMarkup.new(:target => html, :indent => 2)
+      builder.declare! :DOCTYPE, :html, :PUBLIC, "-//W3C//DTD XHTML 1.0 Strict//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
+      builder.html do
+        builder.head { builder.title("Swicky request result") }
+        builder.body do
+          builder.h1("Result Code")
+          builder.p(result.to_s)
+          builder.h1("Message")
+          builder.p(message)
+        end
+      end
+      html
+    end
+    
+  end
+end

data/lib/swicky/json_encoder.rb

@@ -0,0 +1,175 @@
+module Swicky
+
+  # Takes a number of triples and encodes them in the SIMILE JSON format
+  class JsonEncoder
+
+    def initialize(triples)
+      @triples = triples
+      @types_hash = {}
+      @properties_hash = {}
+      @label_hash = {}
+      @label_inverse = {}
+    end
+
+    def to_json
+      @items ||= begin
+        items = []
+        # First a round to make sure that each item has a label
+        triple_hash.each { |object, values| values['label'] = make_label!(object, values) }
+        # Now build the items themselves
+        triple_hash.each { |object, values| items += build_item(object, values) }
+        items
+      end
+      hashy = { 'items' => @items, 'types' => @types_hash, 'properties' => @properties_hash }
+      { 'items' => @items, 'types' => @types_hash, 'properties' => @properties_hash }.to_json
+    end  
+
+    private
+
+    def triple_hash
+      @triple_hash ||= begin
+        triple_hash = {}
+        # Sort all the triples into a hash, mapping all predicates
+        # to a single subject entry and all objects into a single
+        # predicate entry for each subject or predicate
+        @triples.each do |triple|
+          subject = triple.shift.to_uri
+          triple_hash[subject] ||= {}
+          predicate = triple.shift.to_uri
+          triple_hash[subject][predicate] ||= []
+          triple_hash[subject][predicate] << triple.first
+        end
+        triple_hash
+      end
+    end
+
+    # Builds the entry for one "item". This alwasys returns an array, as there may
+    # be additional items created as placeholders for label references
+    def build_item(object, values)
+      items = []
+      item = {}
+      item['uri'] = object.to_s
+
+      item['type'] = make_types!(values)
+      item['label'] = values.delete('label')
+
+      # Add the normal predicates
+      values.each do |predicate, objects|
+        predicate_local = make_predicate_local(predicate)
+        resource_labels, additional_items = as_labels(objects)
+        item[predicate_local] = resource_labels
+        items += additional_items
+      end
+      
+      items << item
+      items
+    end
+    
+    # Turns the given resources into label references
+    def as_labels(resources)
+      additional_items = []
+      labels = resources.collect do |res| 
+        label, additional = resource_label(res) 
+        additional_items << additional if(additional)
+        label
+      end
+      [(labels.size == 1) ? labels.first : labels, additional_items]
+    end
+    
+    def resource_label(resource)
+      return resource if(resource.is_a?(String))
+      return @label_inverse[resource.to_s] if(@label_inverse[resource.to_s])
+      label = make_label!(resource, {})
+      [label, {'uri' => resource.to_s, 'label' => label}]
+    end
+
+    # Check the type definitions from the given hash and transform them
+    # to "type" entries in the JSON structure
+    def make_types!(hash)
+      # First, check for the types
+      types = hash.delete(get_key_from(N::RDF.type, hash)) || []
+      # Add a default type if we don't have one
+      if(types.empty?)
+        types = [ N::RDF.Resource ]
+      end
+      # All types will be referred to by their local name
+      types.collect! { |type| make_type_local(type) }
+      types
+    end
+    
+    
+    # Create the label: Either use the RDFS label or the last part of th
+    # uri. This also inserts the label into an "inverse" hash so that 
+    # labels can be looked up by the uri
+    def make_label!(uri, hash)
+      return @label_inverse[uri.to_s] if(@label_inverse[uri.to_s]) # label already exists
+      label = hash.delete(get_key_from(N::RDFS.label, hash)) || []
+      if(label.empty?)
+        label = check_label(label_for(uri), uri)
+      else
+        label = check_label(label.first, uri)
+      end
+      
+      label.to_s
+    end
+
+    # Get the part of the the uri that can be used as a label
+    def label_for(uri)
+      /[\/#]?([^\/#]+)\Z/.match(uri.to_s)[1]
+    end
+    
+    # Check if the given label can be used, and adapt it if necessary
+    def check_label(label, uri)
+      label = first_free(label, uri.to_s, @label_hash)
+      @label_inverse[uri.to_s] ||= label
+      label
+    end
+
+    # Little kludge for getting badly-specified keys
+    def get_key_from(key, hash)
+      hash.keys.find { |k| k.to_s == key.to_s }
+    end
+    
+    # Finds the first "free" element in the hash. This checks
+    # if hash[initial_value] is empty or equal to "value", if that is not the
+    # case if will try "initial_value2", "initial_value3", ... until the
+    # condition is fulfilled
+    def first_free(initial_key, value, hash)
+      candidate = initial_key
+      hash[candidate] ||= value
+      count = 1
+      while(hash[candidate] != value)
+        count += 1
+        candidate = "#{initial_key}#{count}"
+        hash[candidate] ||= value
+      end
+      candidate
+    end
+
+    # Create the local name for the predicate, and add the definition
+    # to the "properties" hash if necessary. This will also attempt to
+    # avoid collisions if some predicates map to the same local name
+    #
+    # TODO: Doesn't force RDF:label etc to map to the "correct" local 
+    #       name in case of collisions
+    def make_predicate_local(predicate)
+      first_free(predicate.to_uri.local_name, { 'uri' => predicate.to_s, 'valueType' => 'item' }, @properties_hash)
+    end
+
+    # Making local for types
+    def make_type_local(type)
+      first_free(type.to_uri.local_name, { 'uri' => type.to_s }, @types_hash)
+    end
+
+
+    # The entry for the "properties" hash for the given predicate
+    def predicate_property(predicate_uri)
+      {
+        "uri" => predicate_url,
+        "valueType" => "item"
+      }
+    end
+
+  end
+
+end

data/lib/swicky/notebook.rb

@@ -0,0 +1,128 @@
+require 'tempfile'
+
+module Swicky
+  
+  # Represents a SWicky Notebook in the RDF store. This wraps the queries to handle 
+  # the SWicky annotations and user notebooks.
+  #
+  # A notebook is an RDF subgraph that is store in its own context.
+  #
+  # All parameters for this class that end up in RDF queries will be sanitized 
+  # automatically
+  class Notebook
+    
+    include TaliaUtil::UriHelper
+    extend TaliaUtil::UriHelper
+    
+    attr_reader :user_url, :url
+    
+    def initialize(user_name, notebook_name)
+      @user_url = self.class.user_url(user_name)
+      @url = self.class.notebook_url(user_name, notebook_name)
+    end
+    
+    def data
+      @data ||= ActiveRDF::Query.new(N::URI).select(:s, :p, :o).distinct.where(:s, :p, :o, url).execute
+    end
+    
+    def xml_data
+      TaliaUtil::Xml::RdfBuilder.xml_string_for_triples(data)
+    end
+    
+    def delete
+      ActiveRDF::FederationManager.delete(nil, nil, nil, url)
+      ActiveRDF::FederationManager.delete(user_url, N::TALIA.hasSwickyNotebook, url)
+      ActiveRDF::FederationManager.delete(url, N::RDF.type, N::TALIA.SwickyNotebook)
+    end
+    
+    def load(xml_file)
+      @data = nil
+      begin
+        ActiveRDF::ConnectionPool.write_adapter.load(xml_file, 'rdfxml', url)
+      rescue Exception => e
+        puts "\tProblem loading #{xml_file.to_s}: (#{e.message}) File not loaded!"
+        puts e.backtrace
+      end
+      ActiveRDF::FederationManager.add(user_url, N::TALIA.hasSwickyNotebook, url)
+      ActiveRDF::FederationManager.add(url, N::RDF.type, N::TALIA.SwickyNotebook)
+    end
+    
+    def create(xml_data)
+      # Make a temp file for the data
+      tmpfile = Tempfile.new('xml_notebook')
+      tmpfile << xml_data
+      tmpfile.close
+      # Load into store
+      load(tmpfile.path)
+      # remove the temp file
+      tmpfile.unlink
+    end
+    
+    def exist?
+      ActiveRDF::Query.new(N::URI).select(:user).where(:user, N::TALIA.hasSwickyNotebook, url).execute.size > 0
+    end
+    
+    class << self
+      def find_all(user_name = nil)
+        nb_query = ActiveRDF::Query.new(N::URI).select(:notebook).distinct
+        nb_query.where(:notebook, N::RDF.type, N::TALIA.SwickyNotebook)
+        nb_query.where(user_url(user_name), N::TALIA.hasSwickyNotebook, :notebook) if(user_name)
+        nb_query.execute
+      end
+      
+      def user_url(user_name)
+        sanitize_sparql(N::LOCAL + "users/#{user_name}").to_uri
+      end
+      
+      def notebook_url(user_name, notebook_name)
+        sanitize_sparql(user_url(user_name) + '/swicky_notebooks/' + notebook_name).to_uri
+      end
+      
+      def coordinates_for(url)
+        url = sanitize_sparql(url).to_uri
+        frag_qry = ActiveRDF::Query.new(N::URI).select(:coordinates).distinct
+        frag_qry.where(:fragment, N::DISCOVERY.isPartOf, url)
+        frag_qry.where(:fragment, N::SWICKY.hasCoordinates, :coordinates)
+        frag_qry.where(:note, N::SWICKY.refersTo, :fragment)
+        frag_qry.execute.collect { |coord| coord.to_s }
+      end
+      
+      def annotations_for_url(url)
+        url = sanitize_sparql(url).to_uri
+        select_annotations([:note, N::SWICKY.refersTo, url])
+      end
+      
+      def annotations_for_xpointer(xpointer)
+        xpointer = sanitize_sparql(xpointer).to_uri
+        select_annotations([:note, N::SWICKY.refersTo, :fragment], [:fragment, N::SWICKY.hasCoordinates, xpointer])
+      end
+      
+      private
+      
+      def select_annotations(*note_matching)
+        # Select all triples on the notes
+        note_triples_qry = ActiveRDF::Query.new(N::URI).select(:note, :predicate, :object).distinct
+        note_matching.each { |conditions| note_triples_qry.where(*conditions) }
+        note_triples = note_triples_qry.where(:note, :predicate, :object).execute
+        # Select all statements on the triples
+        statement_triples_qry = ActiveRDF::Query.new(N::URI).select(:statement, :predicate, :object).distinct
+        note_matching.each { |conditions| statement_triples_qry.where(*conditions) }
+        statement_triples_qry.where(:note, N::SWICKY.hasStatement, :statement).where(:statement, :predicate, :object)
+        result_triples = note_triples + statement_triples_qry.execute
+        # TODO: Fix this to better query once available in ActiveRDF
+        additional_triples = []
+        result_triples.each do |trip|
+          additional_triples += ActiveRDF::Query.new(N::URI).select(:predicate, :object).where(trip[1].to_uri, :predicate, :object).execute.collect { |result| [trip[1].to_uri] + result }
+          if(trip.last.respond_to?(:uri))
+            additional_triples += ActiveRDF::Query.new(N::URI).select(:predicate, :object).where(trip.last, :predicate, :object).execute.collect { |result| [trip.last] + result }
+          end
+        end
+        
+        # Return all results
+        result_triples + additional_triples
+      end
+      
+    end
+    
+  end
+end

data/lib/talia_core/active_source.rb

@@ -21,7 +21,7 @@ module TaliaCore
   class ActiveSource < ActiveRecord::Base
     
     # Act like an ActiveRdfResource
-    include RDFS::ResourceLike
+    include ActiveRDF::ResourceLike
     
     extend ActiveSourceParts::ClassMethods
     extend ActiveSourceParts::Finders

data/lib/talia_core/active_source_parts/xml/generic_reader.rb

@@ -15,10 +15,12 @@ module TaliaCore
       # present. If attributes for one source are imported in more than one place, all
       # subsequent calls will merge the newly imported attributes with the existing ones.
       class GenericReader
+        
 
         extend TaliaUtil::IoHelper
         include TaliaUtil::IoHelper
         include TaliaUtil::Progressable
+        include TaliaUtil::UriHelper
 
         # Helper class for state
         class State
@@ -163,13 +165,6 @@ module TaliaCore
 
         private
 
-
-        # Removes all characters that are illegal in IRIs, so that the
-        # URIs can be imported
-        def irify(uri)
-          N::URI.new(uri.to_s.gsub( /[{}|\\^`\s]/, '+')).to_s
-        end
-
         # Call the handler method for the given element. If a block is given, that
         # will be called instead
         def call_handler(element)

data/lib/talia_core/active_source_parts/xml/rdf_builder.rb

@@ -3,18 +3,11 @@ module TaliaCore
     module Xml
 
       # Class for creating xml-rdf data
-      class RdfBuilder < BaseBuilder
+      class RdfBuilder < TaliaUtil::Xml::RdfBuilder
 
-        # Writes a simple "flat" triple. If the object is a string, it will be
-        # treated as a "value" while an object (ActiveSource or N::URI) will be treated
-        # as a "link"
-        def write_triple(subject, predicate, object)
-          subject = subject.respond_to?(:uri) ? subject.uri.to_s : subject
-          predicate = predicate.respond_to?(:uri) ? predicate : N::URI.new(predicate) 
-          @builder.rdf :Description, "rdf:about" => subject do
-            write_predicate(predicate, [ object ])
+        def self.build_source(source)
+          make_xml_string { |build| build.write_source(source) }
           end
-        end
 
         # Writes a complete source to the rdf
         def write_source(source)
@@ -24,58 +17,18 @@ module TaliaCore
               write_predicate(predicate, source[predicate])
             end
           end
-        end
-
-        private 
 
-        # Build the structure for the XML file and pass on to
-        # the given block
-        def build_structure
-          @builder.rdf :RDF, self.class.namespaces do 
-            yield
+          source.inverse_predicates.each do |predicate|
+            source.inverse[predicate].each do |inverse_subject|
+              @builder.rdf :Description, 'rdf:about' => inverse_subject do
+                write_predicate(predicate, [source])
+              end
+            end
           end
         end
 
 
-        def self.namespaces
-          @namespaces ||= begin
-            namespaces = {}
-            N::Namespace.shortcuts.each { |key, value| namespaces["xmlns:#{key.to_s}"] = value.to_s }
-            namespaces
           end
         end
-
-        # Build an rdf/xml string for one predicate, with the given values
-        def write_predicate(predicate, values)
-          values.each { |val| write_single_predicate(predicate, val) }
-        end # end method
-
-        def write_single_predicate(predicate, value)
-          is_property = value.respond_to?(:uri)
-          value_properties = is_property ? { 'value' => value } : extract_values(value.to_s)
-          value = value_properties.delete('value')
-          @builder.tag!(predicate.to_name_s, value_properties) do
-            if(is_property)
-              @builder.rdf :Description, 'rdf:about' => value.uri.to_s
-            else
-              @builder.text!(value)
-            end
           end
         end
-
-        # Splits up the value, extracting encoded language codes and RDF data types. The 
-        # result will be returned as a hash, with the "true" value being "value"
-        def extract_values(value)
-          prop_string = PropertyString.parse(value)
-          result = {}
-          result['value'] = prop_string
-          result['rdf:datatype'] = prop_string.type if(prop_string.type)
-          result['xml:lang'] = prop_string.lang if(prop_string.lang)
-          
-          result
-        end
-        
-      end
-    end 
-  end
-end

data/lib/talia_core/active_source_parts/xml/source_builder.rb

@@ -27,7 +27,11 @@ module TaliaCore
       #     </source>
       #     ...
       #   </sources>
-      class SourceBuilder < BaseBuilder
+      class SourceBuilder < TaliaUtil::Xml::BaseBuilder
+        
+        def self.build_source(source)
+          make_xml_string { |build| build.write_source(source) }
+        end
         
         # Builds the RDF for a single source
         def write_source(source)

data/lib/talia_core/initializer.rb

@@ -303,7 +303,7 @@ module TaliaCore
         # Logginging goes to standard talia logger
         ActiveRdfLogger.logger = talia_logger
 
-        ConnectionPool.add_data_source(rdf_connection_opts)
+        ActiveRDF::ConnectionPool.add_data_source(rdf_connection_opts)
       end
 
       # Configure the namespaces
@@ -353,7 +353,7 @@ module TaliaCore
         return unless(@config['auto_ontologies'] && !['false', 'no'].include?(@config['auto_ontologies'].downcase))
         onto_dir = File.join(TALIA_ROOT, @config['auto_ontologies'])
         raise(SystemInitializationError, "Cannot find configured ontology dir #{onto_dir}") unless(File.directory?(onto_dir))
-        adapter = ConnectionPool.write_adapter
+        adapter = ActiveRDF::ConnectionPool.write_adapter
         raise(SystemInitializationError, "Ontology autoloading without a context-aware adapter deletes all RDF data. This is only allowed in testing, please load the ontology manually.") unless(adapter.supports_context? || (@environment == 'testing'))
         raise(SystemInitializationError, "Ontology autoloading requires 'load' capability on the adapter.") unless(adapter.respond_to?(:load))
 

data/lib/talia_core/rdf_import.rb

@@ -53,17 +53,17 @@ module TaliaCore
       # 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 = ActiveRDF::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)
+        ActiveRDF::FederationManager.delete(N::TALIA.rdf_context_space, N::TALIA.rdf_file_context, nil)
       end
 
       private
 
       def adapter
-        @adapter ||= ConnectionPool.write_adapter
+        @adapter ||= ActiveRDF::ConnectionPool.write_adapter
       end
 
       # Prepare the context for the ontology import. All contexts will be registered
@@ -80,7 +80,7 @@ module TaliaCore
           N::URI.new(N::TALIA + context)
         end
         
-        FederationManager.add(N::TALIA.rdf_context_space, N::TALIA.rdf_file_context, file_context)
+        ActiveRDF::FederationManager.add(N::TALIA.rdf_context_space, N::TALIA.rdf_file_context, file_context)
         
         file_context
       end