talia_core 0.4.3 → 0.4.4

data/lib/talia_core/active_source_parts/finders.rb

@@ -0,0 +1,158 @@
+module TaliaCore
+  module ActiveSourceParts
+
+    # All class methods that are used for finding sources.
+    module Finders
+
+
+      # Finder also accepts uris as "ids". There are also some additional options
+      # that are accepted:
+      # 
+      # [*:find_through*] accepts and array with an predicate name and an object
+      #                   value/uri, to search for predicates that match the given predicate/value 
+      #                   combination
+      # [*:type*] specifically looks for sources with the given type.
+      # [*:find_through_inv*] like :find_through, but for the "inverse" lookup
+      # [*:prefetch_relations*] if set to "true", this will pre-load all semantic
+      #                         relations for the sources (experimental, not fully implemented yet)
+      def find(*args)
+        prefetching = false
+        if(args.last.is_a?(Hash))
+          options = args.last
+          options.to_options!
+          prefetching =  options.delete(:prefetch_relations)
+          if(options.empty?) # If empty we remove the args hash, so that the 1-param uri search works
+            args.pop
+          else
+            prepare_options!(options)
+          end
+        end
+        
+        result = if(args.size == 1 && (uri_s = uri_string_for(args[0])))
+          src = super(:first, :conditions => { :uri => uri_s })
+          raise(ActiveRecord::RecordNotFound, "Not found: #{uri_s}") unless(src)
+          src
+        else
+          super
+        end
+
+        prefetch_relations_for(result) if(prefetching)
+
+        result
+      end
+      
+      # Modify the count helper so that it can use the advanced options of the 
+      # ActiveSource #find routine
+      def count(*args)
+        if((options = args.last).is_a?(Hash))
+          options.to_options!
+          options.delete(:prefetch_relations) # This is not relevant for counting
+          prepare_options!(options)
+        end
+        super
+      end
+
+      # Find a list of sources which contains the given token inside the local name.
+      # This means that the namespace it will be excluded.
+      #
+      #   Sources in system:
+      #     * http://talia.org/one
+      #     * http://talia.org/two
+      #
+      #   Source.find_by_uri_token('a') # => [ ]
+      #   Source.find_by_uri_token('o') # => [ 'http://talia.org/one', 'http://talia.org/two' ]
+      #
+      # NOTE: It internally use a MySQL function, as sql condition, to find the local name of the uri.
+      def find_by_uri_token(token, options = {})
+        find(:all, { 
+          :conditions => [ "LOWER(SUBSTRING_INDEX(uri, '/', -1)) LIKE ?", '%' + token.downcase + '%' ], 
+          :order => "uri ASC" }.merge!(options))
+      end
+
+      # Find the Sources within the given namespace by a partial local name
+      def find_by_partial_local(namespace, local_part, options = {})
+        namesp = N::URI[namespace]
+        return [] unless(namesp)
+        find(:all, { 
+          :conditions => [ 'uri LIKE ?', "#{namesp.uri}#{local_part}%" ], 
+          :order => "uri ASC"}.merge!(options))
+      end
+
+      # Find the fist Source that matches the given URI.
+      # It's useful for admin pane, because users visit:
+      #   /admin/sources/<source_id>/edit
+      # but that information is not enough, since we store
+      # into the database the whole reference as URI:
+      #   http://localnode.org/av_media_sources/source_id
+      def find_by_partial_uri(id, options = {})
+        find(:all, { :conditions => ["uri LIKE ?", '%' + id + '%'] }.merge!(options))
+      end
+      
+      private
+      
+      # Checks if the :find_through option is set. If so, this expects the
+      # option to have 2 values: The first representing the URL of the predicate
+      # and the second the URL or value that should be matched.
+      #
+      # An optional third parameter can be used to force an object search on the
+      # semantic_properties table (instead of active_sources) - if not present
+      # this will be auto-guessed from the "object value", checking if it appears
+      # to be an URL or not.
+      #
+      #   ...find(:find_through => [N::RDF::something, 'value', true]
+      def check_for_find_through!(options)
+        if(f_through = options.delete(:find_through))
+          assit_kind_of(Array, f_through)
+          raise(ArgumentError, "Passed non-hash conditions with :find_through") if(options.has_key?(:conditions) && !options[:conditions].is_a?(Hash))
+          raise(ArgumentError, "Cannot pass custom join conditions with :find_through") if(options.has_key?(:joins))
+          predicate = f_through[0]
+          obj_val = f_through[1]
+          search_prop = (f_through.size > 2) ? f_through[2] : !(obj_val.to_s =~ /:/)
+          options[:joins] = default_joins(!search_prop, search_prop)
+          options[:conditions] ||= {}
+          options[:conditions]['semantic_relations.predicate_uri'] = predicate.to_s
+          if(search_prop)
+            options[:conditions]['obj_props.value'] = obj_val.to_s
+          else
+            options[:conditions]['obj_sources.uri'] = obj_val.to_s
+          end
+        end
+      end
+
+      # Check for the :find_through_inv option. This expects the 2 basic values
+      # in the same way as :find_through.
+      #
+      # find(:find_through_inv => [N::RDF::to_me, my_uri]
+      def check_for_find_through_inv!(options)
+        if(f_through = options.delete(:find_through_inv))
+          assit_kind_of(Array, f_through)
+          raise(ArgumentError, "Passed non-hash conditions with :find_through") if(options.has_key?(:conditions) && !options[:conditions].is_a?(Hash))
+          raise(ArgumentError, "Cannot pass custom join conditions with :find_through") if(options.has_key?(:joins))
+          options[:joins] = default_inv_joins
+          options[:conditions] ||= {}
+          options[:conditions]['semantic_relations.predicate_uri'] = f_through[0].to_s
+          options[:conditions]['sub_sources.uri'] = f_through[1].to_s
+        end
+      end
+
+
+      # Checks for the :type option in the find options. This is the same as
+      # doing a :find_through on the rdf type
+      def check_for_type_find!(options)
+        if(f_type = options.delete(:type))
+          options[:find_through] = [N::RDF::type, f_type.to_s, false]
+          check_for_find_through!(options)
+        end
+      end
+      
+      # Takes the "advanced" options that can be passed to the find method and
+      # converts them into "standard" find options.
+      def prepare_options!(options)
+        check_for_find_through!(options)
+        check_for_type_find!(options)
+        check_for_find_through_inv!(options)
+      end
+
+    end
+  end
+end

data/lib/talia_core/active_source_parts/predicate_handler.rb

@@ -17,7 +17,7 @@ module TaliaCore
           raise(RangeError, "Too many sources for prefetching.") if(sources.size > limit)
           src_hash = {}
           sources.each { |src| src_hash[src.id] = src }
-          conditions = ['subject_id in (?)', src_hash.keys.join(', ')]
+          conditions = { :subject_id => src_hash.keys }
           joins = ActiveSource.sources_join
           joins << ActiveSource.props_join
           relations = SemanticRelation.find(:all, :conditions => conditions,
@@ -51,20 +51,19 @@ module TaliaCore
       # so that the object will always be the same as long as the parent source
       # lives.
       def get_objects_on(predicate)
-        TaliaCore::logger.warn "GETTING OBJECTS (#{predicate}) #{@type_cache.inspect}"
         @type_cache ||= {}
         active_wrapper = @type_cache[predicate.to_s]
 
-
         if(active_wrapper.nil?)
-          # If this is a prefetched source we have everything - no use looking further
-          # TODO: Returns an Array instead of a wrapper
-          return [] if(@prefetched)
-          
           active_wrapper = SemanticCollectionWrapper.new(self, predicate)
+          
+          # If this is a prefetched source we have everything, so we can 
+          # initialize the wrapper without loading anything
+          active_wrapper.init_as_empty! if(@prefetched)
+          
           @type_cache[predicate.to_s] = active_wrapper
         end
-
+        
         active_wrapper
       end
 

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

@@ -1,4 +1,5 @@
 require 'hpricot'
+require 'pathname'
 
 module TaliaCore
   module ActiveSourceParts
@@ -16,6 +17,7 @@ module TaliaCore
       class GenericReader
 
         extend TaliaUtil::IoHelper
+        include TaliaUtil::IoHelper
         include TaliaUtil::Progressable
 
         # Helper class for state
@@ -28,11 +30,14 @@ module TaliaCore
           # See the IoHelper class for help on the options. A progressor may
           # be supplied on which the importer will report it's progress.
           def sources_from_url(url, options = nil, progressor = nil)
-            open_generic(url, options) { |io| sources_from(io, progressor) }
+            open_generic(url, options) { |io| sources_from(io, progressor, url) }
           end
 
-          def sources_from(source, progressor = nil)
+          # Reader the sources from the given IO stream. You may specify a base
+          # url to help the reader to decide from where files should be opened.
+          def sources_from(source, progressor = nil, base_url=nil)
             reader = self.new(source)
+            reader.base_file_url = base_url if(base_url)
             reader.progressor = progressor
             reader.sources
           end
@@ -91,6 +96,17 @@ module TaliaCore
           end
           @sources.values
         end
+        
+        # This is the "base" for resolving file URLs. If a file URL is found
+        # to be relative, it will be relative to this URL
+        def base_file_url
+          @base_file_url ||= TALIA_ROOT
+        end
+        
+        # Assign a new base url
+        def base_file_url=(new_base_url)
+          @base_file_url = base_for(new_base_url)
+        end
 
         def add_source_with_check(source_attribs)
           assit_kind_of(Hash, source_attribs)
@@ -103,10 +119,10 @@ module TaliaCore
             @sources[uri].each do |key, value|
               next unless(new_value = source_attribs.delete(key))
 
-              assit(!((key.to_sym == :type) && (value != 'TaliaCore::DummySource') && (value != new_value)), "Type should not change during import, may be a format problem. (From #{value} to #{new_value})")
+              assit(!((key.to_sym == :type) && (value != 'TaliaCore::SourceTypes::DummySource') && (value != new_value)), "Type should not change during import, may be a format problem. (From #{value} to #{new_value})")
               if(new_value.is_a?(Array) && value.is_a?(Array))
                 # If both are Array-types, the new elements will be appended
-                # and duplicates nwill be removed
+                # and duplicates will be removed
                 @sources[uri][key] = (value + new_value).uniq
               else
                 # Otherwise just replace
@@ -184,18 +200,27 @@ module TaliaCore
 
         # Adds a value for the given predicate (may also be a database field)
         def add(predicate, object, required = false)
+          # We need to check if the object elements are already strings -
+          # otherwise we would *.to_s the PropertyString objects, which would
+          # destroy the metadata in them.
           if(object.kind_of?(Array))
-            object.each { |obj| set_element(predicate, obj.to_s, required) }
+            object.each { |obj| set_element(predicate, obj.is_a?(String) ? obj : obj.to_s, required) }
           else
-            set_element(predicate, object.to_s, required)
+            set_element(predicate, object.is_a?(String) ? object : object.to_s, required)
           end
         end
         
+        # Adds a value with the given prediate and language/type information
+        def add_i18n(predicate, object, lang, type=nil)
+          object = object.blank? ? nil : TaliaCore::PropertyString.new(object, lang, type)
+          add(predicate, object)
+        end
+        
         # Adds a date field. This will attempt to parse the original string
         # and write the result as an ISO 8061 compliant date string. Note
         # that this won't be able to parse everything you throw at it, though.
         def add_date(predicate, date, required = false, fmt = nil)
-          add(predicate, parse_date(date, fmt), required)
+          add(predicate, to_iso8601(parse_date(date, fmt)), required)
         end
         
         # Adds a date interval as an ISO 8061 compliant date string. See
@@ -208,7 +233,7 @@ module TaliaCore
           elsif(end_date.blank?)
             add_date(predicate, end_date, true, fmt)
           else
-            add(predicate, "#{parse_date(start_date, fmt)}/#{parse_date(end_date, fmt)}", required)
+            add(predicate, "#{to_iso8601(parse_date(start_date, fmt))}/#{to_iso8601(parse_date(end_date, fmt))}", required)
           end
         end
 
@@ -221,7 +246,7 @@ module TaliaCore
           end
           if(object.kind_of?(Array))
             object.each do |obj| 
-              raise(ArgumentError, "Cannot add relation on database field") if(ActiveSource.db_attr?(predicate))
+              raise(ArgumentError, "Cannot add relation on database field <#{predicate}> - <#{object.inspect}>") if(ActiveSource.db_attr?(predicate))
               set_element(predicate, "<#{irify(obj)}>", required) 
             end
           else
@@ -230,14 +255,63 @@ module TaliaCore
           end
         end
 
-        # Add a file to the source being imported
+        # Add a file to the source being imported. See the DataLoader module for a description of
+        # the possible options
         def add_file(urls, options = {})
           return if(urls.blank?)
           urls = [ urls ] unless(urls.is_a?(Array))
-          files = urls.collect { |url| { :url => url.to_s, :options => options } }
+          files = urls.collect { |url| { :url => get_absolute_file_url(url), :options => options } }
           @current.attributes[:files] = files if(files.size > 0)
         end
 
+        # Gets an absolute path to the given file url, using the base_file_url
+        def get_absolute_file_url(url)
+          orig_url = url.to_s.strip
+          
+          url = file_url(orig_url)
+          # If a file:// was stripped from the url, this means it will always point
+          # to a file
+          force_file = (orig_url != url)
+          # Indicates wether the base url is a network url or a file/directory
+          base_is_net = !base_file_url.is_a?(String)
+          # Try to find if we have a "net" URL if we aren't sure if this is a file. In
+          # case the base url is a network url, we'll always assume that the
+          # url is also a net thing. Otherwise we only have a net url if it contains a
+          # '://' string
+          is_net_url = !force_file && (base_is_net || url.include?('://'))
+          # The url is absolute if there is a : character to be found
+          
+          
+          if(is_net_url)
+            base_is_net ? join_url(base_file_url, url) : url
+          else
+            base_is_net ? url : join_files(base_file_url, url)
+          end
+        end
+        
+        # Joins the two files. If the path is an absolute path,
+        # the base_dir is ignored
+        def join_files(base_dir, path)
+          if(Pathname.new(path).relative?)
+            File.join(base_dir, path)
+          else
+            path
+          end
+        end
+        
+        # Joins the two url parts. If the path is an absolute URL,
+        # the base_url is ignored.
+        def join_url(base_url, path)
+          return path if(path.include?(':')) # Absolute URL contains ':'
+          if(path[0..0] == '/')
+            new_url = base_url.clone
+            new_url.path = path
+            new_url.to_s
+          else
+            (base_file_url + path).to_s
+          end
+        end
+
         # Returns true if the given source was already imported. This can return false
         # if you call this for the currently importing source. 
         def source_exists?(uri)
@@ -337,7 +411,10 @@ module TaliaCore
 
         # Get the content of exactly one child element of type "elem" of the
         # currently importing element.
+        #
+        # If elem is set to :self, this will give the content of the current element
         def from_element(elem)
+          return @current.element.inner_text.strip if(elem == :self)
           elements = all_elements(elem)
           elements = elements.uniq if(elements.size > 1) # Try to ignore dupes
           raise(ArgumentError, "More than one element of #{elem} in #{@current.element.inspect}") if(elements.size > 1)
@@ -352,6 +429,13 @@ module TaliaCore
           result
         end
         
+        # Get the iso8601 string for the date
+        def to_iso8601(date)
+          return nil unless(date)
+          date = DateTime.parse(date) unless(date.respond_to?(:strftime))
+          date.strftime('%Y-%m-%dT%H:%M:%SZ')
+        end
+        
         # Parses the given string and returns it as a date object
         def parse_date(date, fmt = nil)
           return nil if(date.blank?)

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

@@ -66,22 +66,15 @@ module TaliaCore
         # 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 = {}
-          # First split for the type
-          type_split = value.split('^^')
-          # Check if any of the elements contains a language string
-          type_split = type_split.collect { |element| extract_lang(element, result) }
-          result['rdf:datatype'] = type_split.last if(type_split.size > 1)
-          result['value'] = (type_split.first || '')
+          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
-
-        # Helper to extract a language string. The lang value, if any, will be added to the hash
-        def extract_lang(value, hash)
-          lang_split = value.split('@')
-          hash['xml:lang'] = lang_split.last if(lang_split.size > 1)
-          lang_split.first || ''
-        end
+        
       end
     end 
   end

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

@@ -6,9 +6,14 @@ module TaliaCore
       class SourceReader < GenericReader
 
         element :source do
-          nested :attribute do 
-            add from_element(:predicate), all_elements(:value)
-            add_rel from_element(:predicate), all_elements(:object)
+          nested :attribute do
+            predicate = from_element(:predicate)
+            # We need to treat each value separately, as the can have 'xml:lang'
+            # attributes
+            nested :value do
+              add_i18n predicate, from_element(:self), from_attribute('xml:lang')
+            end
+            add_rel predicate, all_elements(:object)
           end
           add_file all_elements(:file)
         end

data/lib/talia_core/data_types/data_loader.rb

@@ -26,13 +26,14 @@ module TaliaCore
         # will *always* attempt to determine the mime type through the location parameter, unless
         # an explicit mime type is given.
         def create_from_url(uri, options = {})
-          mime_type = options[:mime_type] || options['mime_type']
-          location = options[:location] || options['location']
+          options.to_options!
+          options.assert_valid_keys(:mime_type, :location, :http_credentials)
+          
+          mime_type = options[:mime_type] 
+          location = options[:location]
           # If a Mime type is given, use that.
           if(mime_type)
             mime_type = Mime::Type.lookup(mime_type) if(mime_type.is_a?(String))
-          elsif(location)
-            mime_type = Mime::Type.lookup_by_extension(File.extname(location)[1..-1])
           end
 
           data_records = []
@@ -49,13 +50,15 @@ module TaliaCore
           # If we have a "standard" uri, we cut off at the last slash (the
           # File.basename would use the system file separator)
           location ||= uri.rindex('/') ? uri[(uri.rindex('/') + 1)..-1] : uri
-
+          
           if(is_file)
-            mime_type ||= Mime::Type.lookup_by_extension(File.extname(location)[1..-1])
+            mime_type ||= mime_by_location(location)
             open_and_create(mime_type, location, uri, true)
           else
             open_from_url(uri, options[:http_credentials]) do |io|
               mime_type ||= Mime::Type.lookup(io.content_type)
+              # Just in case we didn't get any content type
+              mime_type ||= mime_by_location(location)
               open_and_create(mime_type, location, io, false)
             end
           end
@@ -63,6 +66,11 @@ module TaliaCore
         end
 
         private
+        
+        # Get the mime type from the location
+        def mime_by_location(location)
+          Mime::Type.lookup_by_extension(File.extname(location)[1..-1].downcase)
+        end
 
         # The main loader. This will handle the lookup from the mapping and the creating of the
         # data objects. Depending on the setting of is_file, the source parameter will be interpreted

data/lib/talia_core/data_types/data_record.rb

@@ -11,6 +11,8 @@ module TaliaCore
       belongs_to :source, :class_name => 'TaliaCore::ActiveSource'
       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 ======================
@@ -74,7 +76,9 @@ module TaliaCore
           #
           # source_data = source_data_type.classify.constantize.find_by_location(location, :limit => 1)
           #
-          source_data = self.find(:first, :conditions => ["type = ? AND location = ?", source_data_type.camelize, location])
+          data_type = "TaliaCore::DataTypes::#{source_data_type.camelize}"
+          source_data = self.find(:first, :conditions => ["type = ? AND location = ?", data_type, location])
+          
           raise ActiveRecord::RecordNotFound if source_data.nil?
           source_data
         end

data/lib/talia_core/data_types/iip_data.rb

@@ -1,7 +1,7 @@
 module TaliaCore
   module DataTypes
     
-    # Class to manage IIP Image data type
+    # Class to manage IIP Image data type. FIXME: Check if this correctly destroys existing files.
     class IipData < FileRecord
       
       # Returns the IIP server configured for the application

data/lib/talia_core/data_types/mime_mapping.rb

@@ -2,12 +2,15 @@ module TaliaCore
   module DataTypes
     
     # Mapping from Mime types to data classes and importing methods. Currently uses a fixed 
-    # default mapping
+    # 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]
+        
         raise(ArgumentError, "No data class registered for type #{mime_type.inspect}") unless(mapping)
         mapping
       end
@@ -22,7 +25,7 @@ module TaliaCore
         map[:loader] || map[:type]
       end
       
-      # Currently this is only the default mapping
+      # Currently there is only the default mapping
       def mapping_hash
         @mapping ||= {
           :xml => { :type => XmlData },
@@ -38,7 +41,9 @@ module TaliaCore
           :png => { :type => ImageData, :loader => :create_iip },
           :gif => { :type => ImageData, :loader => :create_iip },
           :pdf => { :type => PdfData },
-          :text => { :type => SimpleText }
+          :text => { :type => SimpleText },
+          # Default fallback handler
+          :default => { :type => FileRecord }
         }
       end
       

data/lib/talia_core/errors.rb

@@ -22,4 +22,8 @@ end
 
 # Indicates an error in a query
 class QueryError < RuntimeError
+end
+
+# Indicates an error with import data
+class ImportError < RuntimeError
 end

data/lib/talia_core/initializer.rb

@@ -160,9 +160,6 @@ module TaliaCore
         # 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"] = {
@@ -315,10 +312,6 @@ module TaliaCore
         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#")
 
@@ -387,7 +380,7 @@ module TaliaCore
       end
 
       def load_core_ext
-        path_to_core_ext = File.join(TALIA_ROOT, 'vendor', 'plugins', 'talia_core', 'lib', 'core_ext')
+        path_to_core_ext = File.join(TALIA_CODE_ROOT, 'lib', 'core_ext')
         Dir[path_to_core_ext + '/**/*.rb'].each { |f| require f}
       end
       

data/lib/talia_core/property_string.rb

@@ -0,0 +1,58 @@
+module TaliaCore
+  
+  # Handling of RDF string values. These values can contain both locale (language)
+  # and type information. (E.g. "Some value^^string@en")
+  #
+  # This class will parse the value string an make all elements available as separate
+  # accessors.
+  class PropertyString < String
+    
+    attr_accessor :type, :lang
+    
+    # Create a new object by parsing the given property string
+    def self.parse(property_string)
+      self.new.parse(property_string)
+    end
+    
+    # Create a new object from the given values. No parsing is done here.
+    def initialize(property_string = '', language = nil, type = nil)
+      @lang = language
+      @type = type
+      self.replace(property_string)
+    end
+    
+    # Parses the given string into a PropertyString
+    def parse(property_string)
+      # First split for the type
+      type_split = property_string.split('^^')
+      # Check if any of the elements contains a language string
+      type_split = type_split.collect { |el| extract_lang(el) }
+      @type = (type_split.size > 1) ? type_split.last : nil
+      self.replace(type_split.first || '')
+    end
+
+    # Gives the "internal representation" - this should be equivalent
+    # to the string from which the object was created
+    def to_rdf
+      value = self.clone
+      value << '^^' << type if(type)
+      value << '@' << lang if(lang)
+      value
+    end
+    
+    # Inspect shows the real content
+    def inspect
+      "\"#{self}\" <lang: #{lang.inspect} - type: #{type.inspect}>"
+    end
+    
+    private
+
+    # Helper to extract a language string. The lang value, if any, will be added to the hash
+    def extract_lang(value)
+      lang_split = value.split('@')
+      @lang ||= (lang_split.size > 1) ? lang_split.last : nil
+      lang_split.first || ''
+    end
+    
+  end
+end

data/lib/talia_core/semantic_collection_item.rb

@@ -27,7 +27,8 @@ module TaliaCore
       @fat_relation || @plain_relation
     end
 
-    # Return the "value" (Semantic relation value or the related ActiveSource)
+    # Return the "value" (Semantic relation value or the related ActiveSource).
+    # String values will actually be PropertyString strings
     def value
       semprop = object.is_a?(SemanticProperty)
       if(@object_type)
@@ -36,7 +37,7 @@ module TaliaCore
         @object_type.new(object.uri.to_s)
       else
         # Plain, return the object or the value for SemanticProperties
-        semprop ? object.value : object
+        semprop ? PropertyString.parse(object.value) : object
       end
     end