talia_core 0.4.5 → 0.4.6

data/VERSION.yml

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

data/config/rdfstore.yml

@@ -7,7 +7,7 @@ test:
   type: sesame
   location: ./sesame_test.db
   backend: native
-development: 
+development:
   type: sesame
   location: ./sesame_development.db
   backend: native

data/generators/talia_base/talia_base_generator.rb

@@ -13,7 +13,8 @@ class TaliaBaseGenerator < Rails::Generator::Base
       m.directory 'config/initializers'
       m.file "config/talia_initializer.rb", "config/initializers/talia.rb"
       m.file "config/routes.rb", "config/routes.rb", :collision => :ask
-      m.file "talia.sh", "talia.sh", :shebang => '/bin/sh', :chmod => 0755
+      m.file "talia.sh", "talia.sh", :shebang => '/bin/sh', :chmod => 0755=
+      m.file "config/warble.rb", "config/warble.rb"
       
       # Install the scripts
       m.directory 'script'

data/generators/talia_base/templates/config/talia_initializer.rb

@@ -5,4 +5,7 @@ TLoad::setup_load_path
 TaliaCore::Initializer.environment = ENV['RAILS_ENV']
 TaliaCore::Initializer.run("talia_core")
 
-TaliaCore::SITE_NAME = TaliaCore::CONFIG['site_name'] || 'Discovery Source'
+TaliaCore::SITE_NAME = TaliaCore::CONFIG['site_name'] || 'Talia Digital Library System'
+
+# You may add mapping for additional data types here.
+# TaliaCore::DataTypes::MimeMapping.add_mapping(:jpeg, TaliaCore::DataTypes::ImageData, :create_iip)

data/generators/talia_base/templates/config/warble.rb

@@ -0,0 +1,82 @@
+# Warbler web application assembly configuration file
+Warbler::Config.new do |config|
+  # Temporary directory where the application is staged
+  # config.staging_dir = "tmp/war"
+
+  # Application directories to be included in the webapp.
+  config.dirs = %w(app config lib vendor)
+
+  # Additional files/directories to include, above those in config.dirs
+  # config.includes = FileList["db"]
+  config.includes = FileList['ontologies/**']
+
+  # Additional files/directories to exclude
+  # config.excludes = FileList["lib/tasks/*"]
+  # ActiveScaffold needs to be exclude as there are circular symlinks inside...
+  config.excludes = FileList["vendor/jruby*", "vendor/plugins/active_scaffold/test/*"]
+
+  # Additional Java .jar files to include.  Note that if .jar files are placed
+  # in lib (and not otherwise excluded) then they need not be mentioned here.
+  # JRuby and JRuby-Rack are pre-loaded in this list.  Be sure to include your
+  # own versions if you directly set the value
+  # config.java_libs += FileList["lib/java/*.jar"]
+
+  # Loose Java classes and miscellaneous files to be placed in WEB-INF/classes.
+  # config.java_classes = FileList["target/classes/**.*"]
+
+  # One or more pathmaps defining how the java classes should be copied into
+  # WEB-INF/classes. The example pathmap below accompanies the java_classes
+  # configuration above. See http://rake.rubyforge.org/classes/String.html#M000017
+  # for details of how to specify a pathmap.
+  # config.pathmaps.java_classes << "%{target/classes/,}p"
+
+  # Gems to be included. You need to tell Warbler which gems your application needs
+  # so that they can be packaged in the war file.
+  # The Rails gems are included by default unless the vendor/rails directory is present."
+  %w(talia_core activerecord-jdbcmysql-adapter jruby-openssl jdbc-mysql oai).each do |gem|
+    config.gems << gem
+  end
+  # config.gems << "tzinfo"
+
+  # Uncomment this if you don't want to package rails gem.
+  # config.gems -= ["rails"]
+
+  # The most recent versions of gems are used.
+  # You can specify versions of gems by using a hash assignment:
+  # config.gems["rails"] = "2.0.5"
+
+  # Include gem dependencies not mentioned specifically
+  config.gem_dependencies = true
+
+  # Files to be included in the root of the webapp.  Note that files in public
+  # will have the leading 'public/' part of the path stripped during staging.
+  # config.public_html = FileList["public/**/*", "doc/**/*"]
+
+  # Pathmaps for controlling how public HTML files are copied into the .war
+  # config.pathmaps.public_html = ["%{public/,}p"]
+
+  # Name of the war file (without the .war) -- defaults to the basename
+  # of RAILS_ROOT
+  # config.war_name = "mywar"
+
+  # Value of RAILS_ENV for the webapp
+  config.webxml.rails.env = 'production'
+
+  # Application booter to use, one of :rack, :rails, or :merb. (Default :rails)
+  # config.webxml.booter = :rails
+
+  # When using the :rack booter, "Rackup" script to use.
+  # The script is evaluated in a Rack::Builder to load the application.
+  # Examples:
+  # config.webxml.rackup = %{require './lib/demo'; run Rack::Adapter::Camping.new(Demo)}
+  # config.webxml.rackup = require 'cgi' && CGI::escapeHTML(File.read("config.ru"))
+
+  # Control the pool of Rails runtimes. Leaving unspecified means
+  # the pool will grow as needed to service requests. It is recommended
+  # that you fix these values when running a production server!
+  config.webxml.jruby.min.runtimes = 2
+  config.webxml.jruby.max.runtimes = 4
+
+  # JNDI data source name
+  # config.webxml.jndi = 'jdbc/rails'
+end

data/generators/talia_base/templates/script/configure_talia

@@ -129,6 +129,18 @@ print "Enter the URI for your site: "
 site_url = readl(true)
 
 if(read_yn('Do you want to use the IIP image server?'))
+  init_file = File.join(rails_dir, 'config', 'initializers', 'talia.rb')
+  if(File.exist?(init_file))
+    puts "Adding the creation handler to your talia_initializer. Note that you will need 'vips' installed."
+    File.open(init_file, 'a')  do |io|
+      io.puts ''
+      io.puts '# IIP creation handlers, added automatically'
+      %w(jpeg tiff png gif bmp).each { |t| io.puts "TaliaCore::DataTypes::MimeMapping.add_mapping(:#{t}, TaliaCore::DataTypes::ImageData, :create_iip)" }
+      io.puts ''
+    end
+  else
+    puts "WARNING: Initializer file for Talia not found. You will need to add the image handler for the MIME types manually."
+  end
   puts
   print "Enter the URL of your IIP server, or the port number (for default URL on localhost): "
   iip_url = readl
@@ -150,10 +162,14 @@ puts
 puts "Configuring the Sesame RDF store (change the config by hand for stores other than Sesame)"
 puts
 backends = %w(native memory rdbms http)
-print "Enter the sesame backend to use (#{backends.join('|')}): "
-while(!(backends.include?(backend = readl)))
+print "Enter the sesame backend to use (#{backends.join('|')}) (default: native): "
+backend = readl
+backend = 'native' if(backend.blank?)
+while(!(backends.include?(backend)))
   puts "#{backend} is not a valid backend"
   print "Enter the backend (#{backends.join('|')}: )"
+  backend = readl
+  backend = 'native' if(backend.blank?)
 end
 
 %w(production test development).each do |env|
@@ -181,7 +197,7 @@ when 'rdbms':
     print "Enter the password for the connection: "
     pass = readl
   end
-  %(production test development).each do |env|
+  %w(production test development).each do |env|
     rdf_config[env]['driver'] = driver
     rdf_config[env]['user'] = user
     rdf_config[env]['pass'] = pass
@@ -196,10 +212,9 @@ when 'http':
     print "Enter the password for the connection: "
     pass = readl
   end
-  %(production test development).each do |env|
-    rdf_config[env]['driver'] = driver
-    rdf_config[env]['user'] = user
-    rdf_config[env]['pass'] = pass
+  %w(production test development).each do |env|
+    rdf_config[env]['user'] = user unless(user.blank?)
+    rdf_config[env]['pass'] = pass unless(pass.blank?)
     print "Enter the URL for the '#{env}' environment: "
     rdf_config[env]['url'] = readl(true)
   end
@@ -211,7 +226,8 @@ if(iip_directory != '')
   talia_config.iip_root_directory_location = iip_directory
 end
 
-print "Enter the path to store the data files (return for default): "
+puts ''
+print "Enter the path to store general data files (return for default): "
 data_directory = readl
 
 if(data_directory != '')

data/lib/talia_core/data_types/data_loader.rb

@@ -77,10 +77,10 @@ module TaliaCore
         # in a different way. If it is a file, the file name will be passed in here. If it is
         # a URL, the method will receive the io object of the open connection as the source
         def open_and_create(mime_type, location, source, is_file)
-          data_type = loader_type_from(mime_type)
+          data_type = MimeMapping.loader_type_from(mime_type)
           if(data_type.is_a?(Symbol))
             raise(ArgumentError, "No handler found for loading: #{data_type}") unless(self.respond_to?(data_type))
-            self.send(data_type, mime_type, location, source, is_file)
+            MimeMapping.class_type_from(mime_type).send(data_type, mime_type, location, source, is_file)
           else
             raise(ArgumentError, "Registered handler for loading must be a method symbol or class. (#{data_type})") unless(data_type.is_a?(Class))
             data_record = data_type.new

data/lib/talia_core/data_types/data_record.rb

@@ -12,8 +12,6 @@ module TaliaCore
       before_create :set_mime_type # Mime type must be saved before the record is written
       
       # validates_presence_of :source
-      
-      extend MimeMapping
 
       # Declaration of main abstract methods ======================
       # Some notes: every subclasses of DataRecord must implement

data/lib/talia_core/data_types/file_store.rb

@@ -114,7 +114,7 @@ module TaliaCore
       
       # Assign the STI subclass, perfoming a mime-type lookup.
       def assign_type(content_type)
-        self.type = self.class.class_type_from(content_type).name
+        self.type = MimeMapping.class_type_from(content_type).name
       end
       
       

data/lib/talia_core/data_types/mime_mapping.rb

@@ -1,54 +1,101 @@
 module TaliaCore
   module DataTypes
-    
+
     # Mapping from Mime types to data classes and importing methods. Currently uses a fixed 
     # default mapping. If the mime type is not known, it will use a fallback default handler.
-    module MimeMapping
-      
-      def mapping_for(mime_type)
-        mime_type = Mime::Type.lookup(mime_type) if(mime_type.is_a?(String))
-        mapping = mapping_hash[mime_type.to_sym]
-        TaliaCore.logger.warn { "No data class registered for mime type #{mime_type.inspect}, trying default handler." } unless(mapping)
-        mapping ||= mapping_hash[:default]
+    #
+    # The mapping can be configured in Rails' initializer files. Example:
+    #
+    #   TaliaCore::DataTypes::MimeMapping(:tiff, :image_data, :create_iip)
+    class MimeMapping
+
+      class << self
+
+        # Gets the data class for the given mime type
+        def class_type_from(mime_type)
+          mapping_for(mime_type)[:type]
+        end
+
+        def loader_type_from(mime_type)
+          map = mapping_for(mime_type)
+          map[:loader] || map[:type]
+        end
         
-        raise(ArgumentError, "No data class registered for type #{mime_type.inspect}") unless(mapping)
-        mapping
-      end
-      
-      # Gets the data class for the given mime type
-      def class_type_from(mime_type)
-        mapping_for(mime_type)[:type]
-      end
-      
-      def loader_type_from(mime_type)
-        map = mapping_for(mime_type)
-        map[:loader] || map[:type]
-      end
-      
-      # Currently there is only the default mapping
-      def mapping_hash
-        @mapping ||= {
-          :xml => { :type => XmlData },
-          :html =>{ :type => XmlData },
-          :tei => { :type => XmlData },
-          :tei_p5 => { :type => XmlData },
-          :tei_p4 => { :type => XmlData }, 
-          :gml => { :type => XmlData },
-          :wittei => { :type => XmlData },
-          :hnml => { :type => XmlData },
-          :jpeg => { :type => ImageData, :loader => :create_iip },
-          :tiff => { :type => ImageData, :loader => :create_iip },
-          :png => { :type => ImageData, :loader => :create_iip },
-          :gif => { :type => ImageData, :loader => :create_iip },
-          :pdf => { :type => PdfData },
-          :text => { :type => SimpleText },
-          # Default fallback handler
-          :default => { :type => FileRecord }
-        }
+        # Set a new mapping for the given MIME type. If only a class is given, this
+        # will use the class to create new data records from. If a symbol is given
+        # for the class name, this will take the corresponding class from
+        # TaliaCore::DataTypes.
+        #
+        # The loader method can be a symbol, if given it must correspond to a *class* 
+        # method that can be called on type_class and which accepts exactly 4 parameters,
+        # which will be passed in during record creation
+        # 
+        # * Mime type of the record 
+        # * 'location' field of the record
+        # * The record source - this is a descriptive string with either the url
+        #   or the file name from which the data should be fetched
+        # * The is_file flag. This will be true if the source is the name of a
+        #   regular file. Otherwise, the source field should be interpreted as
+        #   a URL.
+        # == Example handler method
+        #
+        #   def data_loader(mime_type, location, source, is_file)
+        def add_mapping(mime_type, data_class, handler = nil)
+          mapping = {}
+          if(!data_class.is_a?(Class))
+            data_class = TaliaCore::DataTypes.const_get(data_class.to_s.camelize)
+          end
+          
+          raise("Error: #{data_class} is not a valid data class.") unless(data_class.is_a?(Class) && (data_class <= DataRecord))
+          
+          mapping[:type] = data_class
+          mapping[:loader] = handler.to_sym if(handler)
+          mapping_hash[symbol_for(mime_type)] = mapping
+          true
+        end
+        
+        private
+
+        def symbol_for(mime_type)
+          mime_type = Mime::Type.lookup(mime_type) unless(mime_type.is_a?(Mime::Type))
+          mime_type.to_sym
+        end
+
+        def mapping_for(mime_type)
+          mapping = mapping_hash[symbol_for(mime_type)]
+          TaliaCore.logger.warn { "No data class registered for mime type #{mime_type.inspect}, trying default handler." } unless(mapping)
+          mapping ||= mapping_hash[:default]
+
+          raise(ArgumentError, "No data class registered for type #{mime_type.inspect}") unless(mapping)
+          mapping
+        end
+
+        # Currently there is only the default mapping
+        def mapping_hash
+          @mapping ||= {
+            :xml => { :type => DataTypes::XmlData },
+            :html =>{ :type => DataTypes::XmlData },
+            :tei => { :type => DataTypes::XmlData },
+            :tei_p5 => { :type => DataTypes::XmlData },
+            :tei_p4 => { :type => DataTypes::XmlData }, 
+            :gml => { :type => DataTypes::XmlData },
+            :wittei => { :type => DataTypes::XmlData },
+            :hnml => { :type => DataTypes::XmlData },
+            :jpeg => { :type => DataTypes::ImageData },
+            :tiff => { :type => DataTypes::ImageData },
+            :png => { :type => DataTypes::ImageData },
+            :gif => { :type => DataTypes::ImageData },
+            :bmp => { :type => DataTypes::ImageData },
+            :pdf => { :type => DataTypes::PdfData },
+            :text => { :type => DataTypes::SimpleText },            
+            # Default fallback handler
+            :default => { :type => FileRecord }
+          }
+        end
+
       end
-      
-      
+
     end
-    
+
   end
 end

data/lib/talia_util/import_job_helper.rb

@@ -5,42 +5,42 @@ module TaliaUtil
   # Helper methods that will be used during import job runs.
   # The import jobs may use the following environment parameters:
   #
-  #  [*base_url*] The base URL or directory. This will be prefixed to all urls, or if it is 
-  #                 a local directory, it will be made the current directory during the import
-  #  [*index*] If given, the importer will try to read this document. While this will still
-  #              support the old-style "hyper" format with sigla, it should usually contain a
-  #              main element called "index" followed by "url" entries. 
-  #  [*xml*] URL of an XML file to import. This is incompatible with the "index" option. 
-  #            If neither "xml" nor "index" are given, the class will try to read the XML data from
-  #            STDIN
-  #  [*importer*] Name of the importer class to be used for the data. Uses the default class if not given
+  # [*base_url*] The base URL or directory. This will be prefixed to all urls, or if it is 
+  #              a local directory, it will be made the current directory during the import
+  # [*index*] If given, the importer will try to read this document. While this will still
+  #           support the old-style "hyper" format with sigla, it should usually contain a
+  #           main element called "index" followed by "url" entries. 
+  # [*xml*] URL of an XML file to import. This is incompatible with the "index" option. 
+  #         If neither "xml" nor "index" are given, the class will try to read the XML data from
+  #         STDIN
+  # [*importer*] Name of the importer class to be used for the data. Uses the default class if not given
   # [*reset_store*] - If this is set, the data store will be cleared before the import
   # [*user*] Username for HTTP authentication, if required
   # [*pass*] Password for HTTP authentication, if required
   # [*callback*] Name of a class. If given, the import will call the #before_import and #after_import
-  #                 methods on an object of that class. The call will receive a block which may be
-  #                 yielded to for each progress step and which can receive the overall number of
-  #                 steps
+  #              methods on an object of that class. The call will receive a block which may be
+  #              yielded to for each progress step and which can receive the overall number of
+  #              steps
   # [*extension*] Only used with index files; file extension to use
   # [*duplicates*] How to deal with elements that already exist in the datastore. This may be
-  #                  set to one of the following options (default: :skip):
-  #                  * :add - Database fields will be updated and the system will add semantic
-  #                    properties as additional values, without removing any of the existing
-  #                    semantic relations. Example: If the data store already
-  #                    contains a title for an element, and the import file contains another
-  #                    for that element, the element will have two titles after the import. 
-  #                    The system will not check for duplicates. Files will always be imported
-  #                    in addition to the existing ones.
-  #                  * :update - Database fields will be updated, and semantic properties will
-  #                    be overwritten with the new value(s). Semantic properties that are not
-  #                    included in the import data will be left untouched. In the example above,
-  #                    the element would only contain the new title. If the element also contained
-  #                    author information, and no author information was in the import file, the
-  #                    existing author information will be untouched. Existing files are replaced
-  #                    if the import contains new files
-  #                  * :overwrite - Database fields will be updated. All semantic data will be
-  #                    deleted before the import. Files are always removed.
-  #                  * :skip - If an element already exists, the import will be skipped.
+  #                set to one of the following options (default: :skip):
+  #                * :add - Database fields will be updated and the system will add semantic
+  #                  properties as additional values, without removing any of the existing
+  #                  semantic relations. Example: If the data store already
+  #                  contains a title for an element, and the import file contains another
+  #                  for that element, the element will have two titles after the import. 
+  #                  The system will not check for duplicates. Files will always be imported
+  #                  in addition to the existing ones.
+  #                * :update - Database fields will be updated, and semantic properties will
+  #                  be overwritten with the new value(s). Semantic properties that are not
+  #                  included in the import data will be left untouched. In the example above,
+  #                  the element would only contain the new title. If the element also contained
+  #                  author information, and no author information was in the import file, the
+  #                  existing author information will be untouched. Existing files are replaced
+  #                  if the import contains new files
+  #                * :overwrite - Database fields will be updated. All semantic data will be
+  #                  deleted before the import. Files are always removed.
+  #                * :skip - If an element already exists, the import will be skipped.
   #
   # [*trace*] Enable tracing output for errors. (By default, this takes the rake task's setting
   #           if possible)

data/test/talia_core/data_types/file_record_test.rb

@@ -153,20 +153,6 @@ module TaliaCore
       new_rec = DataTypes::DataRecord.find(data_record.id)
       assert_equal(expected_content, new_rec.content_string)
     end
-  
-    def test_class_type_from
-      ['text/plain'].each do |mime|
-        assert_equal('SimpleText', DataTypes::FileRecord.class_type_from(mime))
-      end
-
-      @image_mime_types.each { |mime| assert_equal('ImageData', DataTypes::FileRecord.class_type_from(mime)) }
-      
-      ['text/xml', 'application/xml'].each do |mime|
-        assert_equal('XmlData', DataTypes::FileRecord.class_type_from(mime))
-      end
-      
-      assert_equal('DataRecord', DataTypes::FileRecord.class_type_from('application/rtf'))
-    end
     
   end
 end

data/test/talia_core/data_types/mime_mapping_test.rb

@@ -0,0 +1,41 @@
+require 'test/unit'
+
+# Load the helper class
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+module TaliaCore
+
+  # Test the DataRecord storage class
+  class MimeMappingTest < ActiveSupport::TestCase
+    
+    def setup
+      @image_mime_types = ['image/gif', 'image/jpeg', 'image/png', 'image/tiff', 'image/bmp']
+    end
+    
+    def test_class_type_from
+      ['text/plain'].each do |mime|
+        assert_equal(DataTypes::SimpleText, DataTypes::MimeMapping.class_type_from(mime))
+      end
+
+      @image_mime_types.each { |mime| assert_equal(DataTypes::ImageData, DataTypes::MimeMapping.class_type_from(mime), "Wrong type for #{mime} - #{DataTypes::MimeMapping.class_type_from(mime)}") }
+      
+      ['text/xml', 'application/xml'].each do |mime|
+        assert_equal(DataTypes::XmlData, DataTypes::MimeMapping.class_type_from(mime), "Wrong type for #{mime} - #{DataTypes::MimeMapping.class_type_from(mime)}")
+      end
+      
+      assert_equal(DataTypes::FileRecord, DataTypes::MimeMapping.class_type_from('application/rtf'))
+    end
+    
+    def test_add_mime_mapping
+      DataTypes::MimeMapping.add_mapping(Mime::Type.new('foo'), DataTypes::ImageData)
+      assert_equal(DataTypes::ImageData, DataTypes::MimeMapping.class_type_from('foo'))
+    end
+    
+    def test_add_mime_loader
+      DataTypes::MimeMapping.add_mapping(Mime::Type.new('bar'), DataTypes::ImageData, :create_iip)
+      assert_equal(DataTypes::ImageData, DataTypes::MimeMapping.class_type_from(:bar))
+      assert_equal(:create_iip, DataTypes::MimeMapping.loader_type_from(:bar))
+    end
+    
+  end
+end

data/test/test_helper.rb

@@ -24,6 +24,13 @@ module TaliaCore
     # Check if we have old (1.2.3-Rails) style ActiveRecord without fixture cache
     @@new_ar = Fixtures.respond_to?(:reset_cache)
     
+    # The tests expect the system to be set to iip creation
+    TaliaCore::DataTypes::MimeMapping.add_mapping(:jpeg, DataTypes::ImageData, :create_iip)
+    TaliaCore::DataTypes::MimeMapping.add_mapping(:tiff, DataTypes::ImageData, :create_iip)
+    TaliaCore::DataTypes::MimeMapping.add_mapping(:png, DataTypes::ImageData, :create_iip)
+    TaliaCore::DataTypes::MimeMapping.add_mapping(:bmp, DataTypes::ImageData, :create_iip)
+    TaliaCore::DataTypes::MimeMapping.add_mapping(:gif, DataTypes::ImageData, :create_iip)
+    
     # connect the database
     def self.startup
       if(!TaliaCore::Initializer.initialized)

metadata

@@ -1,18 +1,19 @@
 --- !ruby/object:Gem::Specification 
 name: talia_core
 version: !ruby/object:Gem::Version 
-  version: 0.4.5
+  version: 0.4.6
 platform: ruby
 authors: 
   - Danilo Giacomi
   - Roberto Tofani
   - Luca Guidi
+  - Michele Nucci
   - Daniel Hahn
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-12-04 00:00:00 +01:00
+date: 2009-12-15 00:00:00 +01:00
 default_executable: talia
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -66,7 +67,7 @@ dependencies:
             version: 2.0.6
       version: 
   - !ruby/object:Gem::Dependency 
-    name: averell23-bj
+    name: bjj
     type: :runtime
     version_requirement: 
     version_requirements: !ruby/object:Gem::Requirement 
@@ -232,6 +233,7 @@ files:
   - generators/talia_base/templates/app/views/types/show.html.erb
   - generators/talia_base/templates/config/routes.rb
   - generators/talia_base/templates/config/talia_initializer.rb
+  - generators/talia_base/templates/config/warble.rb
   - generators/talia_base/templates/migrations/bj_migration.rb
   - generators/talia_base/templates/migrations/constraint_migration.rb
   - generators/talia_base/templates/migrations/create_active_sources.rb
@@ -403,6 +405,7 @@ test_files:
   - test/talia_core/data_types/file_record_test.rb
   - test/talia_core/data_types/iip_data_test.rb
   - test/talia_core/data_types/image_data_test.rb
+  - test/talia_core/data_types/mime_mapping_test.rb
   - test/talia_core/data_types/pdf_data_test.rb
   - test/talia_core/data_types/xml_data_test.rb
   - test/talia_core/workflow/publication_workflow_test.rb