talia_core 0.5.4 → 0.7.0

data/lib/talia_core/semantic_relation.rb

@@ -1,12 +1,28 @@
 module TaliaCore
+  
+  # The basic class to represent a semantic relation, which is equivalent
+  # to an RDF triple.
+  #
+  # The predicate is directly contained in the record is a string, while
+  # the subject refers to respective ActiveSource object.
+  #
+  # The object of the relation refers either to another ActiveSource or
+  # to a SemanticProperty, depending on the object_type field. This is
+  # a normal polymorphic relation to the active_sources/semantic_properties
+  # table(s)
   class SemanticRelation < ActiveRecord::Base
     
     belongs_to :subject, :class_name => 'TaliaCore::ActiveSource'
     belongs_to :object, :polymorphic => true
     before_destroy :discard_property
+    before_destroy :destroy_dependent_object
+    before_save :check_for_object
 
     # Returns true if the Relation matches the given predicate URI (and value,
-    # if given)
+    # if given). A relation matches if the predicate of this relation is
+    # them same as the predicate given (which can be a String or a Source or
+    # a N::URI) and if the object's value (or uri, if the object is a 
+    # ActiveSource) is the same as the value given.
     def matches?(predicate, value = nil)
       if(value)
         if(value.is_a?(ActiveSource) || value.is_a?(SemanticProperty))
@@ -20,49 +36,84 @@ module TaliaCore
       end
     end
 
-    class << self
-
-      # Retrieve "fat" relations for the given source and property
-      def find_fat_relations(source, predicate)
-        joins = ActiveSource.sources_join
-        joins << ActiveSource.props_join
-        relations = SemanticRelation.find(:all, :conditions => {
-            :subject_id => source.id,
-            :predicate_uri => predicate
-          },
-          :joins => joins,
-          :select => fat_record_select
-        )
-        relations
+    # Return the "value" of the relation. This is usually the same as #object,
+    # except that string values are parsed as PropertyString objects and that
+    # in case the "special type" is set the related resources are made to
+    # be objects of that type (see above).
+    def value
+      semprop = object.is_a?(SemanticProperty)
+      if(special_object_type)
+        assit(object, "Must have object for #{predicate_uri}")
+        raise(ArgumentError, 'Must not have a property for a typed item') if(semprop)
+        special_object_type.new(object.uri.to_s)
+      elsif(semprop)
+        # Plain, return the object or the value for SemanticProperties
+        object.value ? PropertyString.parse(object.value) : object.value
+      else
+        object
       end
-
-      # For selecting "fat" records on the semantic properties
-      def fat_record_select
-        @select ||= begin
-          select = 'semantic_relations.id AS id, semantic_relations.created_at AS created_at, '
-          select << 'semantic_relations.updated_at AS updated_at, '
-          select << 'semantic_relations.rel_order AS rel_order,'
-          select << 'object_id, object_type, subject_id, predicate_uri, '
-          select << 'obj_props.created_at AS property_created_at, '
-          select << 'obj_props.updated_at AS property_updated_at, '
-          select << 'obj_props.value AS property_value, '
-          select << 'obj_sources.created_at AS object_created_at, '
-          select << 'obj_sources.updated_at AS object_updated_at, obj_sources.type AS  object_realtype, '
-          select << 'obj_sources.uri AS object_uri'
-          select
-        end
+    end
+    
+    # An item will be equal to its #value - this is a little hack that lets Enumerable#find and
+    # such methods work easily on collections of SemanticRelation.
+    #
+    # If compare is a SemanticRelation, this will be true if both relations have the same predicate
+    # value.
+    def ==(compare)
+      if(compare.is_a?(SemanticRelation))
+        (self.predicate_uri == compare.predicate_uri) && (self.value == compare.value)
+      else
+        self.value == compare
       end
-
+    end
+    
+    # This will return the "object type" for the current relation. This can
+    # be used to "force" a relation for some predicates.
+    #
+    # This will check if an entry exists for the current predicate has an
+    # entry in #special_types. If yes, the class will be returned.
+    #
+    # If object_type returns a class, the #value method will return objects
+    # of that class for all resources. 
+    #
+    # The default case is that this returns nil, which will cause #value
+    # to return the actual "object" value for relations to resources.
+    def special_object_type
+      self.class.special_types[predicate_uri]
+    end
+    
+    # Simple hash that checks if a type if property requires "special" handling
+    # This will cause the wrapper to accept ActiveSource relations and all
+    # sources will be casted to the given type
+    def self.special_types
+      @special_types ||= {
+        N::RDF.type.to_s => N::SourceClass
+      }
     end
 
     private
     
-    # Discards the "value" property that belongs to this source
+    # If the object of this relation is a SemanticProperty, it will
+    # be deleted from the database by this method.
     def discard_property
       if(object.is_a?(SemanticProperty))
         SemanticProperty.delete(object.id)
       end
     end
+    
+    def destroy_dependent_object
+      object.destroy if(object.is_a?(ActiveSource) && subject.property_options_for(predicate_uri)[:dependent] == :destroy)
+    end
+    
+    # Called on save, this will check if the "same" object already exists in the database.
+    # If yes, it will use the version from the database instead of the one currently attached,
+    # since a "new" source with an existing URI cannot be saved.
+    def check_for_object
+      if(self.object.new_record? && self.object.is_a?(ActiveSource))
+        existing = ActiveSource.find(:first, :conditions => { :uri => self.object.uri.to_s })
+        self.object = (existing || self.object)
+      end
+    end
 
   end
 end

data/lib/talia_core/source.rb

@@ -7,20 +7,23 @@ require 'rdf_resource'
 
 module TaliaCore
 
-  # This represents a Source in the Talia core system.
+  # Base class for most sources in the Talia system. The Source class has some
+  # additional features over the basic ActiveSource class.
   #
-  # Since data for the Source exists both in the database and in the RDF store, the 
-  # handling/saving of data is a bit peculiar at the moment (subject to change in the future):
+  # Most importantly, it contains the "smart" accessor in the same style as
+  # ActiveRDF:
   #
-  # * When a new Source is created, no data is saved
-  # * RDF properties *cannot* be written until the Source has been saved for the first time
-  # * Database properties are *only* written when the save method is called
-  # * RDF properties are written immediately when they are assigned
-  # * To ensure that the data is written, the save method should be called as 
-  #   necessary.
+  #  source.rdf::something
+  #  => SemanticCollection Wrapper
+  #  
+  #  # is the same as:
+  #  source[N::RDF.something]
+  #
+  # There are also 
   class Source < ActiveSource
     # FIXME: Remove methods for old admin panel
 
+    # FIXME: Remove workflow?
     has_one :workflow, :class_name => 'TaliaCore::Workflow::Base', :dependent => :destroy
 
     # The uri will be wrapped into an object
@@ -64,11 +67,11 @@ module TaliaCore
       joins << "LEFT JOIN active_sources AS t_sources ON semantic_relations.object_id = t_sources.id AND semantic_relations.object_type = 'TaliaCore::ActiveSource' "
       joins << "LEFT JOIN semantic_properties ON semantic_relations.object_id = semantic_properties.id AND semantic_relations.object_type = 'TaliaCore::SemanticProperty' "
 
-      property = uri_string_for(property)
+      property = uri_string_for(property, false)
       results = {}
       for val in values
         find(:all )
-        val_str = uri_string_for(val)
+        val_str = uri_string_for(val, false)
         find_parms = params.merge(
         :conditions => ['semantic_properties.value = ? OR t_sources.uri = ?', val_str, val_str],
         :joins => joins
@@ -88,13 +91,16 @@ module TaliaCore
     #
     #   ActiveSource.find_or_instantiate_by_uri('http://talia.org/unexistent', 'Foo Bar')
     #     # => #<TaliaCore::ActiveSource id: nil, uri: "http://talia.org/Foo_Bar">
-    def self.find_or_instantiate_by_uri(uri, local_name)
+    #
+    # TODO: Delete this/old backend method?
+    def self.find_or_instantiate_by_uri(uri, local_name) # :nodoc: 
       result = find_by_uri(uri)
       result ||= self.new(N::LOCAL.to_s + local_name.to_permalink)
     end
 
     # Return an hash of direct predicates, grouped by namespace.
-    def grouped_direct_predicates
+    # TODO: Delete this/old backend method?
+    def grouped_direct_predicates # :nodoc:
       #TODO should it be memoized?
       direct_predicates.inject({}) do |result, predicate|
         predicates = self[predicate].collect { |p| SourceTransferObject.new(p.to_s) }
@@ -106,22 +112,25 @@ module TaliaCore
       end
     end
 
+    # TODO: Delete this/old backend method?
     def predicate_objects(namespace, name) #:nodoc:
       predicate(namespace, name).values.flatten.map(&:to_s)
     end
 
     # Check if the current source is related with the given rdf object (triple endpoint).
-    def associated?(namespace, name, stringified_predicate)
+    # TODO: Delete this/old backend method?
+    def associated?(namespace, name, stringified_predicate) # :nodoc:
       predicate_objects(namespace, name).include?(stringified_predicate)
     end
 
-    # Check if a predicate is changed.
-    def predicate_changed?(namespace, name, objects)
+    # Check if a predicate is changed. TODO: Delete this/old backend method?
+    def predicate_changed?(namespace, name, objects) # :nodoc:
       not predicate_objects(namespace, name).eql?(objects.map(&:to_s))
     end
 
-    attr_reader :predicates_attributes
-    def predicates_attributes=(predicates_attributes)
+    # TODO: Delete this/old backend method?
+    attr_reader :predicates_attributes # :nodoc:
+    def predicates_attributes=(predicates_attributes) # :nodoc:
       @predicates_attributes = predicates_attributes.collect do |attributes_hash|
         attributes_hash['object'] = instantiate_source_or_rdf_object(attributes_hash)
         attributes_hash
@@ -129,7 +138,8 @@ module TaliaCore
     end
 
     # Return an hash of new predicated attributes, grouped by namespace.
-    def grouped_predicates_attributes
+    # TODO: Delete this/old backend method?
+    def grouped_predicates_attributes # :nodoc:
       @grouped_predicates_attributes ||= predicates_attributes.inject({}) do |result, predicate|
         namespace, name = predicate['namespace'], predicate['name']
         predicate = SourceTransferObject.new(predicate['titleized'])
@@ -140,8 +150,9 @@ module TaliaCore
       end
     end
 
-      # Save, associate/disassociate given predicates attributes.
-      def save_predicates_attributes
+      # Save, associate/disassociate given predicates attributes. TODO: Delete this/
+      # old backend method?
+      def save_predicates_attributes # :nodoc:
         each_predicate do |namespace, name, objects|
           objects.each { |object| object.save if object.is_a?(Source) && object.new_record? }
           self.predicate_replace(namespace, name, objects.to_s) if predicate_changed?(namespace, name, objects)
@@ -182,10 +193,16 @@ module TaliaCore
         value.is_a?(Source) && (value.uri == uri)
       end
 
+      # See Source.normalize_uri
       def normalize_uri(uri, label = '')
         self.class.normalize_uri(uri, label)
       end
 
+      # Returns the Collection (or collections) this source is in.
+      def collections
+        Collection.find(:all, :find_through => [N::DCT.hasPart, self])
+      end
+
       protected
 
       # Look at the given attributes and choose to instantiate
@@ -202,7 +219,9 @@ module TaliaCore
       #
       #   http://springfield.org/Homer_Simpson
       #     # => Should instantiate a source with the given uri
-      def instantiate_source_or_rdf_object(attributes)
+      #
+      # TODO: Delete this/old backend method?
+      def instantiate_source_or_rdf_object(attributes) # :nodoc:
         name_or_uri = attributes['titleized']
         if /^\"[\w\s\d]+\"$/.match name_or_uri
           name_or_uri[1..-2]
@@ -216,7 +235,8 @@ module TaliaCore
       end
 
       # Iterate through grouped_predicates_attributes, yielding the given code.
-      def each_predicate(&block)
+      # TODO: Delete this/old backend method?
+      def each_predicate(&block) # :nodoc:
         grouped_predicates_attributes.each do |namespace, predicates|
           predicates.each do |predicate, objects|
             block.call(namespace, predicate, objects.flatten)
@@ -246,10 +266,10 @@ module TaliaCore
 
 
       # Missing methods: This just check if the given method corresponds to a
-      # registered namespace. If yes, this will return a "dummy" handler that
+      # registered namespace. If yes, this will return a DummyHandler that
       # allows access to properties.
       # 
-      # This will allow invocations as namespace::name
+      # This will allow invocations such as namespace::name
       def method_missing(method_name, *args)
         # TODO: Add permission checking for all updates to the model
         # TODO: Add permission checking for read access?

data/lib/talia_core/source_fragment.rb

@@ -0,0 +1,7 @@
+module TaliaCore
+  
+  # A fragment is a "virtual" entitity that describes a part of a source.
+  class SourceFragment
+  end
+  
+end

data/lib/talia_core/source_transfer_object.rb

@@ -7,7 +7,9 @@ module TaliaCore #:nodoc:
   #
   # http://java.sun.com/blueprints/corej2eepatterns/Patterns/TransferObject.html
   # http://java.sun.com/blueprints/patterns/TransferObject.html
-  class SourceTransferObject
+  #
+  # TODO: Remove as part of old admin interface?
+  class SourceTransferObject # :nodoc:
     attr_reader :uri
     
     def initialize(name_or_uri) #:nodoc:

data/lib/talia_core/source_types/agent.rb

@@ -0,0 +1,16 @@
+module TaliaCore
+  module SourceTypes
+
+    # Some item that "has the power to act". This can either be a person or another
+    # entity, like an institution or a corporation
+    class Agent < Source
+
+      has_rdf_type N::DCT.Agent
+
+      singular_property :name, N::DCNS.title
+      singular_property :description, N::DCNS.description
+
+    end
+
+  end
+end

data/lib/talia_core/source_types/dc_resource.rb

@@ -7,12 +7,12 @@ module TaliaCore
 
       # General metadata
       singular_property :identifier, N::DCNS.identifier
-      simple_property :creators, N::DCNS.creator
+      multi_property :creators, N::DCNS.creator
       singular_property :date, N::DCNS.date
       singular_property :description, N::DCNS.description
-      simple_property :publishers, N::DCNS.publisher
+      multi_property :publishers, N::DCNS.publisher
       singular_property :language, N::DCNS.language
-      simple_property :dc_subjects, N::DCNS.subject
+      multi_property :dc_subjects, N::DCNS.subject
       singular_property :rights, N::DCNS.rights
       singular_property :title, N::DCNS.title
 

data/lib/talia_core/source_types/marcont_resource.rb

@@ -0,0 +1,15 @@
+module TaliaCore
+  module SourceTypes
+
+    # A generic SKOS concept. This means that this source represents an entry in
+    # a taxonomy, thesaurus or the like.
+    #
+    # TODO: Stub class at the moment
+    class MarcontResource < Source
+      
+      has_rdf_type N::MARCONT.Resource
+
+    end
+
+  end
+end

data/lib/talia_core/source_types/skos_concept.rb

@@ -0,0 +1,17 @@
+module TaliaCore
+  module SourceTypes
+
+    # A generic SKOS concept. This means that this source represents an entry in
+    # a taxonomy, thesaurus or the like.
+    #
+    # TODO: Stub class at the moment
+    class SkosConcept < Source
+      
+      N::SKOS.Concept
+
+      singular_property :pref_label, N::SKOS.prefLabel
+
+    end
+
+  end
+end

data/lib/talia_dependencies.rb

@@ -2,7 +2,7 @@
 require File.dirname(__FILE__) + '/loader_helper'
 
 # This is also needed for local loading
-RAILS_GEM_VERSION = '2.3.5' unless defined? RAILS_GEM_VERSION
+RAILS_GEM_VERSION = '2.3.10' unless defined? RAILS_GEM_VERSION
 
 # Stuff we may need to load from sources/uninstalled versions
 TLoad::require_module("assit", "assit", "/../../assit") unless(defined?(assit))

data/lib/talia_util.rb

@@ -4,7 +4,7 @@ require File.join(File.dirname(__FILE__), 'talia_dependencies')
 require 'core_ext'
 require 'talia_core/rdf_import'
 require 'talia_util/rdf_update'
-require 'talia_util/progressbar'
+require 'progressbar'
 
 # Stuff we just load from the gems
 gem "builder"

data/lib/talia_util/bar_progressor.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), 'progressbar')
+require File.join(File.dirname(__FILE__), '..', 'progressbar')
 
 module TaliaUtil
   

data/lib/talia_util/image_conversions.rb

@@ -6,6 +6,9 @@ module TaliaUtil
   #
   # Since it calls the command line, it should be compatible both with JRuby
   # and plain Ruby.
+  #
+  # See TaliaCore::Intializer for the options that can be set for the
+  # image conversions
   class ImageConversions
 
     class << self
@@ -43,10 +46,12 @@ module TaliaUtil
         end
       end
 
-      # Create the thumbnail by running the configured creation command.
+      # Create the thumbnail by running the configured creation command. Options are
+      # taken from <tt>talia_core.yml</tt>
       def create_thumb(source, destination)
         thumbnail_size = "#{thumb_options['width']}x#{thumb_options['height']}"
-        thumbnail_command = "#{convert_command} \"#{source}\" -quality 85 -thumbnail \"#{thumbnail_size}>\" -background transparent -gravity center -extent #{thumbnail_size} \"#{destination}\""
+        thumbnail_force = %w(true yes).include?(thumb_options['force']) ? "-background transparent -gravity center -extent #{thumbnail_size}" : ''
+        thumbnail_command = "#{convert_command} \"#{source}\" -quality 85 -thumbnail \"#{thumbnail_size}>\" #{thumbnail_force} \"#{destination}\""
         execute_command(thumbnail_command, destination)
       end
 
@@ -54,6 +59,7 @@ module TaliaUtil
       # command. This automatically creates the file in the correct location
       # (IIP root)
       def create_pyramid(source, destination)
+        # TODO: Options not configurable
         pyramid_command = "#{vips_command} im_vips2tiff \"#{source}\" \"#{destination}\":jpeg:85,tile:256x256,pyramid"
         execute_command(pyramid_command, destination)
       end