talia_core 0.4.0

data/lib/talia_core/initializer.rb

@@ -0,0 +1,427 @@
+require 'assit'
+require 'semantic_naming'
+require 'active_rdf'
+require 'fileutils'
+
+module TaliaCore
+
+  # The TaliaCore initializer is responsible for setting up the Talia core
+  # system, e.g. making the neccessary connections, setting up the
+  # basic namespaces, etc.
+  #
+  # The basic mechanism works like the Rails initializer: Options can be
+  # added to the Hash in a block that is passed to the run method of the
+  # intializers.
+  #
+  # There are two settings that can be made before the configuration is started:
+  # 
+  # <tt>environmemnt</tt> is used to define the environment. This is used to
+  # select the configuration options from the files. This option will default
+  # to <tt>ENV['RAILS_ENV']</tt> if Talia runs in Rails. Otherwise the default
+  # will be "development".
+  # 
+  # <tt>talia_root</tt> is the root directory for the Talia installation. If
+  # unset, the will default to <tt>RAILS_ROOT</tt> in Rails and to the current
+  # directory if Talia is used as a standalone module. This will be used to find
+  # the configuration and data files.
+  #
+  # Usually these options need only to be set if running Talia standalone. In
+  # this case, assign <tt>TaliaCore::Initializer.talia_root</tt> and/or
+  # <tt>TaliaCore::Initializer.environment</tt> before running the 
+  # configuration.
+  #
+  # The options may also be stored in a configuration file; the name of
+  # the file is passed to the initializer.
+  #
+  # = Example config
+  #  
+  #  # If working with Rails, this code goes to the environment.rb
+  #  
+  #  # Set the root directory (optional, for Rails it's automatic)
+  #  TaliaCore::Initializer.talia_root = "/my_directory/my_talia_root/"
+  #  # Set the environment (optional, automatic for rails)
+  #  TaliaCore::Initializer.environment = "development"
+  #  
+  #  # Run the initializer, giving a config file
+  #  # See the example config files for options
+  #  TaliaCore::Initializer.run("talia_core.yml") do |config|
+  #    # Give more confi options. These will overwrite the ones from the 
+  #    # config file
+  #    config['standalone_db'] = "true"
+  #  end
+  class Initializer
+
+    # Is used to set the root directory manually. Must be written before
+    # the configuration is run.
+    cattr_writer :talia_root
+
+    # Is used to manually set the environment. Must be written before
+    # the configuration is run.
+    cattr_writer :environment
+
+    # Indicates if the system has been initialized
+    cattr_reader :initialized
+    @@initialized ||= false
+
+    # Indicates if the initialization was started, 
+    # but not finished
+    cattr_reader :init_started
+    @@init_started ||= false
+
+    class << self
+
+      # Runs the initialization. You can pass a block to this method, which
+      # is run with one parameter: A hash containing the configuration.
+      # 
+      # If a configuration file is given, the contents will be read before the
+      # block is called, the block values will overwrite the settings from the
+      # file.
+      # 
+      # For now, the values are documented in the code below and in the default
+      # configuration file.
+      def run(config_file = nil, &initializer)
+        raise(SystemInitializationError, "System cannot be initialized twice") if(@@initialized || @@init_started)
+
+        @@init_started = true
+
+        # Set the talia root first
+        set_talia_root
+
+        # Set the environmnet
+        set_environment
+
+        # Load the config file if one is given
+        if(config_file)
+          config_file_path = File.join(TALIA_ROOT, 'config', "#{config_file}.yml")
+          @config = YAML::load(File.open(config_file_path))
+        else
+          # Create the default configuration
+          @config = create_default_config()
+        end
+
+        # Start logging
+        set_logger # Set the logger
+        talia_logger.info("TaliaCore initializing with environmnet #{@environment}")
+
+        # Call the user code
+        initializer.call(@config) if(initializer)
+
+        # Initialize the database connection
+        config_db
+
+        # Initialize the ActiveRDF connection
+        config_rdf
+
+        # Configure the namespaces
+        config_namespaces
+
+        # Configure the data directory
+        config_data_directory
+
+        # Configure the iip root directory
+        config_iip_root_directory
+
+        # Configure the ontologies
+        load_ontologies
+
+        # Load the Ruby Core extensions
+        load_core_ext
+
+        # register the default mime types
+        register_mime_types
+
+        # set the $ASSERT flag
+        if(@config["assert"])
+          $ASSERT = true
+        end
+
+        @@initialized = true
+
+        # Set the environment to the configuration
+        @config["environment"] = @@environment
+
+
+        # Make the configuration available as a constant
+        TaliaCore.const_set(:CONFIG, @config)
+
+        talia_logger.info("TaliaCore initialization complete")
+      end
+
+      def talia_logger
+        @logger
+      end
+
+      protected
+
+      # Creates the default values for the config hash
+      def create_default_config
+        config = Hash.new
+
+        # The name of the local node
+        config["local_uri"] = "http://test.dummy/"
+
+        # The "default" namespace
+        config["default_namespace_uri"] = "http://default.dummy/"
+
+        # Connect options for ActiveRDF
+        # Defaults to in-memory RDFLite
+        config["rdf_connection"] = {
+          :type => :rdflite
+        }
+
+        # Indicates if the DB backend (ActiveRecord) is 
+        # used "standalone", which means "outside" a
+        # rails application. 
+        # For the standalone case, the Talia
+        # initializer will make the database connections.
+        # Otherwise, Rails will handle that.
+        config["standalone_db"] = false
+
+        # Configuration for standalone database connection
+        config["db_connection"] = nil
+
+        # Additional namespaces that will be registered at 
+        # startup. If present, this is expected to be a Hash with 
+        # :shortcut => URI pairs
+        config["namespaces"] = nil
+
+        # Whether to set the $ASSERT flag that activates the simple assertions
+        config["assert"] = true
+
+        # Where to find the data directory which will be contain the data
+        config["data_directory_location"] = File.join(TALIA_ROOT, 'data')
+
+        return config
+      end
+
+
+      # Creates a logger if no logger is defined
+      # At the moment, this just creates a logger to the default director
+      def set_logger
+        @logger ||= if(defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER)
+          RAILS_DEFAULT_LOGGER
+        else
+          log_name = @config['standalone_log'] || File.join(TALIA_ROOT, 'log', "talia_core_#{@environment}.log")
+          log_level = @config['standalone_log_level'] ? Logger.const_get(@config['standalone_log_level']) : default_log_level
+          FileUtils.makedirs(File.dirname(log_name))
+          logger = Logger.new(log_name)
+          logger.level = log_level
+          logger
+        end
+      end
+
+      # Get the default log level for the standalone log
+      def default_log_level
+        case(@environment)
+        when 'development', 'test':
+          Logger::DEBUG
+        else
+          Logger::WARN
+        end
+      end
+
+      # Set the Talia root directory first. Use the configured directory
+      # if given, otherwise go for the RAILS_ROOT/current directory.
+      def set_talia_root
+        root = if(@@talia_root)
+          @@talia_root
+        elsif(defined?(RAILS_ROOT))
+          RAILS_ROOT
+        else
+          '.'
+        end
+        # Use the full path for the root
+        Object.const_set(:TALIA_ROOT, File.expand_path(root))
+      end
+
+      # Set the environmet to be used for config selection
+      def set_environment
+        if(@@environment)
+          @environment = @@environment
+        elsif(ENV['RAILS_ENV'])
+          @environment = ENV['RAILS_ENV']
+        else
+          @environment = "development"
+        end
+        @@environment = @environment
+      end
+
+      # Gets connection options from a file. The default_opts are the ones
+      # that will be used if no file is given. If both file and default are given,
+      # the method will overwrite the defaults.
+      def connection_opts(default_opts, config_file)
+        options = default_opts
+
+        # First check for the file
+        if(config_file)
+          if(default_opts)
+            talia_logger.warn("Database options will be overwritten by config file values.")
+          end
+
+          config_path = File.join(TALIA_ROOT, 'config', "#{config_file}.yml")
+          options = YAML::load(File.open(config_path))[@environment]
+        end
+
+        options
+      end
+
+      # The connection options for the standalone database connection
+      def db_connection_opts
+        connection_opts(@config["db_connection"], @config["db_file"])
+      end
+
+
+      # Configure the database connection
+      def config_db
+        # Initialize the database connection
+        if(@config["standalone_db"])
+          talia_logger.info("TaliaCore using standalone database")
+
+          ActiveRecord::Base.configurations['talia'] = db_connection_opts
+          ActiveRecord::Base.establish_connection(:talia)
+          ActiveRecord::Base.logger = talia_logger
+        else
+          talia_logger.info("TaliaCore using exisiting database connection.")
+          unless(ActiveRecord::Base.logger)
+            talia_logger.info("ActiveRecord logger not active, setting it to Talia logger")
+            ActiveRecord::Base.logger = talia_logger
+          end
+        end
+      end
+
+      # Get the RDF configuration options
+      def rdf_connection_opts
+        options = connection_opts(@config["rdf_connection"], @config["rdf_connection_file"])
+        # Make the keys into symbols, as needed by ActiveRDF
+        rdf_cfg = Hash.new
+        options.each { |key, value| rdf_cfg[key.to_sym] = value }
+
+        rdf_cfg
+      end
+
+      # Configure the RDF connection
+      def config_rdf
+        # Logginging goes to standard talia logger
+        ActiveRdfLogger.logger = talia_logger
+
+        ConnectionPool.add_data_source(rdf_connection_opts)
+      end
+
+      # Configure the namespaces
+      def config_namespaces
+        # Register the local name
+        N::Namespace.shortcut(:local, @config["local_uri"])
+        talia_logger.info("Local Domain: #{N::LOCAL}")
+
+        # Register the default name
+        N::Namespace.shortcut(:default, @config["default_namespace_uri"])
+        talia_logger.debug("Default Domain: #{N::DEFAULT}")
+
+        # Register namespace for database dupes
+        N::Namespace.shortcut(:talia, "http://talia.discovery-project.eu/wiki/TaliaInternal#")
+
+        # Register additional namespaces
+        if(@config["namespaces"])
+          assit_kind_of(Hash, @config["namespaces"])
+          @config["namespaces"].each_pair do |shortcut, uri|
+            N::Namespace.shortcut(shortcut, uri)
+          end
+        end
+      end
+
+      # Configure the data directory
+      def config_data_directory
+        data_directory = if(@config['data_directory_location'])
+          # Replace the data directory location variables
+          @config["data_directory_location"].gsub(/TALIA_ROOT/, TALIA_ROOT)
+        else
+          File.join(TALIA_ROOT, 'data')
+        end
+
+        @config['data_directory_location'] = data_directory
+      end
+
+      # Configure the data directory
+      def config_iip_root_directory
+        data_directory = if(@config['iip_root_directory_location'])
+          # Replace the iip root directory location variables
+          @config["iip_root_directory_location"].gsub(/TALIA_ROOT/, TALIA_ROOT)
+        else
+          File.join(TALIA_ROOT, 'iip_root')
+        end
+
+        @config['iip_root_directory_location'] = data_directory
+      end
+
+      # Autoload ontologies, if configured
+      def load_ontologies
+        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
+        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))
+
+        # Clear out the RDF
+        if(adapter.supports_context?)
+          TaliaCore::RdfImport.clear_file_contexts
+        else
+          adapter.respond_to?(:clear) ? adapter.clear : TaliaUtil::Util::flush_rdf
+        end
+
+        loaded_ontos = []
+
+        Dir.foreach(onto_dir) do |file|
+          if(file =~ /\.owl$|\.rdf$|\.rdfs$/)
+            file = File.expand_path(File.join(onto_dir, file))
+            adapter.supports_context? ? TaliaCore::RdfImport.import_file(file, 'rdfxml', :auto) : TaliaCore::RdfImport.import_file(file, 'rdfxml')
+            loaded_ontos << File.basename(file)
+          end
+        end
+
+        klasses, updated = TaliaUtil::RdfUpdate::rdfs_from_owl
+
+        puts "Ontologies autoloaded: #{loaded_ontos.join(', ')} (#{updated} of #{klasses} updated)"
+      end
+
+      def load_core_ext
+        path_to_core_ext = File.join(TALIA_ROOT, 'vendor', 'plugins', 'talia_core', 'lib', 'core_ext')
+        Dir[path_to_core_ext + '/**/*.rb'].each { |f| require f}
+      end
+      
+      # Register the default mime types
+      def register_mime_types
+
+        # Add new mime types for use in respond_to blocks:
+        # Mime::Type.register "text/richtext", :rtf
+        # Mime::Type.register_alias "text/html", :iphone
+        Mime::Type.register "application/rdf+xml", :rdf
+
+        # The are used for serving "static" widget content by mime type
+        Mime::Type.register "image/gif", :gif, [], %w( gif )
+        Mime::Type.register "image/jpeg", :jpeg, [], %w( jpeg jpg jpe jfif pjpeg pjp )
+        Mime::Type.register "image/png", :png, [], %w( png )
+        Mime::Type.register "image/tiff", :tiff, [], %w( tiff tif )
+        Mime::Type.register "image/bmp", :bmp, [], %w( bmp )
+        Mime::Type.register "video/isivideo", :isivideo, [], %w( fvi )
+        Mime::Type.register "video/mpeg", :mpeg, [], %w( mpeg mpg mpe mpv vbs mpegv )
+        Mime::Type.register "video/x-mpeg2", :xmpeg2, [], %w( mpv2 mp2v )
+        Mime::Type.register "video/msvideo", :msvideo, [], %w( avi )
+        Mime::Type.register "video/quicktime", :quicktime, [], %w( qt mov moov )
+        Mime::Type.register "video/vivo", :vivo, [], %w( viv vivo )
+        Mime::Type.register "video/wavelet", :wavelet, [], %w( wv )
+        Mime::Type.register "video/x-sgi-movie", :xsgimovie, [], %w( movie )
+        Mime::Type.register "application/pdf", :pdf, [], %w( pdf )
+        %w( hnml tei tei-p4 tei-p5 gml wittei).each do |type|
+          Mime::Type.register "application/xml+#{type}", type.gsub(/-/, '_').to_sym, [], [ type ] 
+        end
+      end
+      
+    end
+  end
+
+  # Add logger to the module
+  def self.logger
+    Initializer.talia_logger
+  end
+end

data/lib/talia_core/ordered_source.rb

@@ -0,0 +1,228 @@
+module TaliaCore
+
+  # This class provides an ordering on the related sources. It will load the
+  # related elements into an array. All changes made to the OrderedSource will
+  # reflect on the Array, and will only be persisted to the store on save.
+  #
+  # The collection is contained in the ordered_objects - if you ever use that
+  # accessor all "ordering" relations for the object will be completely overwritten
+  # on saving. (You can still assign the predicates manually as long as the
+  # ordered_objects accesssor is not called before saving.)
+  class OrderedSource < ActiveSource
+    
+    attr_reader :current_index
+    
+    before_save :rewrite_order_relations
+
+    # Initialize SeqContainer
+    def self.new(uri)
+      @resource = super(uri)
+      #      @resource.save!
+      #      @resource.types << RDF::Seq.uri
+      #      @resource
+    end
+    
+    # Returns all elements (not the relations) in an ordered array. Unlike the
+    # ordered_objects accessor this will not include nil elements and the
+    # index will not have a 1:1 relation to the position of the elment.
+    #
+    # The ordering of the elements will be preserved, though.
+    def elements
+      # execute query
+      ordered_objects.compact
+    end
+    
+    # Returns the first element of the collection
+    def first
+      ordered_objects.find { |el| !el.nil? }
+    end
+
+    # return the item at position index.
+    # 
+    #  * index: int
+    #  * return value: TaliaCore::ActiveSource
+    def at(index)
+      @current_index = index
+      ordered_objects.at(index)
+    end
+    
+    # return next item
+    # * current_element: int or string. Current element. If nil, the index is the last integer used with at method
+    def next(current_element = nil)
+      set_current_index_for(current_element)
+      
+      # if current element is nil, next must return first value
+      @current_index ||= 0
+
+      if (@current_index < (size - 1))
+        return at(@current_index + 1) # TODO: Current is not increased, is this intentional? Do we need this method at all?
+      else
+      raise "Last item reached"
+    end
+    end
+
+    # return previous item
+    # * current_element: int or string. Current element. If nil, the index is the last integer used with at method
+    def previous(current_element = nil)
+      set_current_index_for(current_element)
+      
+      # if current element is nil, next must return first value
+      @current_index = (size + 1) if @current_index.nil?
+
+      if (@current_index > 1) # TODO: This assumes a one-base array, not really useful
+        return at(@current_index - 1) # TODO: See above
+      else
+      raise "First item reached"
+    end
+    end
+    
+    # Return the "size" of the collection. This is actually the maximum position
+    # index that is used. The value is cached internally and will be increased
+    # on insert_at (only if inserting at a value larger at the current size) and
+    # on the add operation. If elements are added in another way, the count
+    # may be off, but in that case it would be off anyway. Delete will decrease
+    # the size by 1, if the index removed equals the size (this is a rough guess
+    # which may be off!)
+    # The cached counter will be reset on saving.
+    def size
+      ordered_objects.size
+      end
+    
+    # Inserts an element at the given index.
+    def insert_at(index, object)
+      write_for_index(ordered_objects, index, object)
+    end
+    
+    # Add new item to ordered source. This will add the object after the last
+    # element. ATTENTION: If you add on an empty collection, it will start at
+    # index 1 (One), for backwards compatability
+    def add(object)
+      position = (size > 0) ? size : 1
+      insert_at(position, object)
+    end
+    
+    # remove an existing object to ordered source. This will reorder the
+    # existing positions if deleting from the middle! If you don't want
+    # that use insert_at(index, nil)
+    def delete(index)
+      ordered_objects.delete_at(index)
+    end
+  
+    # remove all existing object to ordered source
+    # TODO: This will not reliably delete all elements, since the size
+    #       value is not reliable
+    def delete_all
+      @ordered_objects = []
+    end
+    
+    # replace item as position index with object
+    # * index: int
+    # * object: TaliaCore::ActiveSource
+    def replace(index, object)
+      replace_for_index(ordered_objects, index, object)
+    end
+    
+    # Find the position index of the given object. This will always find the
+    # first occurence
+    def find_position_by_object(object)
+      ordered_objects.index(object)
+    end
+      
+    # return string for index
+    def index_to_predicate(index)
+      self.class.index_to_predicate(index)
+    end
+      
+    # return index of predicate
+    def predicate_to_index(predicate)
+      self.class.predicate_to_index(predicate)
+    end
+    
+    # Returns all the objects that are ordered in an array where the array
+    # index equals the position of the object in the ordered set. The array
+    # is zero-based, position that don't have an object attached will be set to 
+    # nil.
+    def ordered_objects
+      return @ordered_objects if(@ordered_objects)
+      relations = query
+      # Let's assume the follwing is a sane assumption ;-)
+      # Even if a one-base collection comes in, we need to push just one element
+      @ordered_objects = Array.new(relations.size)
+      # Now add the elements so that the relation property is reflected
+      # on the position in the array
+      relations.each do |rel|
+        index = rel.rel_order
+        write_for_index(@ordered_objects, index, rel.object)
+      end
+
+      @ordered_objects
+    end
+    
+    # return string for index
+    def self.index_to_predicate(index)
+      'http://www.w3.org/1999/02/22-rdf-syntax-ns#_' << ("%06d" % index.to_i) 
+    end
+    
+    # return index of predicate
+    def self.predicate_to_index(predicate)
+      predicate.sub('http://www.w3.org/1999/02/22-rdf-syntax-ns#_', '').to_i
+    end
+
+    private
+
+    # Set the current index for the given element, which can be a number, a
+    # predicate string or an object contained in the collection. Passing nil
+    # causes it to do nothing.
+    def set_current_index_for(current_element)
+      return unless(current_element)
+
+      case current_element
+      when Fixnum   then @current_index = current_element
+      when String   then @current_index = predicate_to_index(current_element)
+      when TaliaCore::ActiveSource
+        # find semantic relation
+        pos = find_position_by_object(current_element)
+        # if no relations is found
+        raise "Object isn't in current OrderedSource" if pos.nil?
+        # else we have a position
+        @current_index = pos
+      else
+        raise "Class #{current_element.class} not supported"
+      end
+    end
+
+    # This will be called before saving and will completely rewrite the relations
+    # that make up the ordered store, based on the internal array
+    def rewrite_order_relations
+      return unless(@ordered_objects) # If this is nil, the relations weren't loaded in the first place
+      objects = ordered_objects # Fetch them before deleting
+      # Now destroy the existing elements
+      SemanticRelation.destroy_all(['subject_id = ? AND rel_order IS NOT NULL', self.id])
+      # rewrite from the relations array
+      objects.each_index do |index|
+        if(obj = objects.at(index)) # Check if there's a value to handle
+          # Create a new relation with an order
+          self[index_to_predicate(index)].add_with_order(obj, index)
+        end
+      end
+    end
+
+    # Helper to "grow" an array to the given index. Unless replace is true, it
+    # will raise an error if the element already exists.
+    def write_for_index(arr, index, value, replace = false)
+      raise(RuntimeError, "Duplicate element found on index #{index}") if(arr.at(index) && !replace)
+      arr[index] = value
+    end
+    
+    def replace_for_index(arr, index, value)
+      write_for_index(arr, index, value, true)
+    end
+
+    # execute query and return the result
+    def query(scope = :all)
+      # execute query
+      self.semantic_relations.find(scope, :conditions => 'rel_order IS NOT NULL', :order => :rel_order)
+    end
+
+  end
+end

data/lib/talia_core/rails_ext/actionpack/action_controller/record_identifier.rb

@@ -0,0 +1,13 @@
+module ActionController # :nodoc:  
+  module RecordIdentifier 
+    def singular_class_name(record_or_class)
+      class_from_record_or_class(record_or_class).underscore.tr('/', '_')
+    end
+    
+    private
+    def class_from_record_or_class(record_or_class)
+      klass = record_or_class.is_a?(Class) ? record_or_class : record_or_class.class
+      klass.to_s.demodulize
+    end
+  end
+end

data/lib/talia_core/rails_ext/actionpack/action_controller.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__) + "/action_controller/*.rb"].sort.each { |file| require(file) }

data/lib/talia_core/rails_ext/actionpack.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__) + "/actionpack/*.rb"].sort.each { |file| require(file) }

data/lib/talia_core/rails_ext.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__) + "/rails_ext/*.rb"].sort.each { |file| require(file) }