talia_core 0.5.4 → 0.7.0

data/lib/swicky/note.rb

@@ -0,0 +1,7 @@
+module Swicky
+  
+  # A Swicky::Note is a note attached to an object (usually a Source or a fragment of a Source)
+  class Note
+  end
+  
+end

data/lib/swicky/notebook.rb

@@ -12,13 +12,20 @@ module Swicky
   class Notebook
     
     include TaliaUtil::UriHelper
+    include ActiveRDF::ResourceLike
     extend TaliaUtil::UriHelper
     
     attr_reader :user_url, :url
     
-    def initialize(user_name, notebook_name)
-      @user_url = self.class.user_url(user_name)
-      @url = self.class.notebook_url(user_name, notebook_name)
+    alias :uri :url
+    
+    def initialize(user_name_or_uri, notebook_name = nil)
+      if(notebook_name)
+        @user_url = self.class.user_url(user_name_or_uri)
+        @url = self.class.notebook_url(user_name_or_uri, notebook_name)
+      else
+        @url = sanitize_sparql(user_name_or_uri).to_uri
+      end
     end
     
     def data
@@ -62,36 +69,79 @@ module Swicky
       ActiveRDF::Query.new(N::URI).select(:user).where(:user, N::TALIA.hasSwickyNotebook, url).execute.size > 0
     end
     
+    def to_uri
+      N::URI.new(uri)
+    end
+    
+    def ==(value)
+      (value.class == self.class) && (value.uri == self.uri)
+    end
+    
     class << self
+      
+      # Find all notebooks for the given user
       def find_all(user_name = nil)
-        nb_query = ActiveRDF::Query.new(N::URI).select(:notebook).distinct
+        nb_query = ActiveRDF::Query.new(Notebook).select(:notebook).distinct
         nb_query.where(:notebook, N::RDF.type, N::TALIA.SwickyNotebook)
         nb_query.where(user_url(user_name), N::TALIA.hasSwickyNotebook, :notebook) if(user_name)
         nb_query.execute
       end
       
+      # Construct the "user" url for the given user name
       def user_url(user_name)
         sanitize_sparql(N::LOCAL + "users/#{user_name}").to_uri
       end
       
+      # Construct the URL for a notebook from the user and notebook name
       def notebook_url(user_name, notebook_name)
         sanitize_sparql(user_url(user_name) + '/swicky_notebooks/' + notebook_name).to_uri
       end
       
+      # Get the "coordinates" (an xpointer in the case of HTML fragments) for all the
+      # fragments that are part of the element with the given url.
       def coordinates_for(url)
+        result = []
         url = sanitize_sparql(url).to_uri
-        frag_qry = ActiveRDF::Query.new(N::URI).select(:coordinates).distinct
+        frag_qry = ActiveRDF::Query.new(N::URI).select(:fragment, :coordinates).distinct
         frag_qry.where(:fragment, N::DISCOVERY.isPartOf, url)
         frag_qry.where(:fragment, N::SWICKY.hasCoordinates, :coordinates)
         frag_qry.where(:note, N::SWICKY.refersTo, :fragment)
-        frag_qry.execute.collect { |coord| coord.to_s }
+        frag_qry.execute.each do |fragment, coordinates|
+          result << {'fragment' => fragment.to_s, 'coordinates' => coordinates.to_s}
+        end
+        result
+      end
+
+      def annotation_list_for_url(url)
+        qry = ActiveRDF::Query.new(N::URI).distinct.select(:note).where(:fragment, N::DISCOVERY.isPartOf, url.to_uri).where(:note, N::SWICKY.refersTo, :fragment).execute
       end
       
+      # Select all the triples for all the annotations (notes) that refer to the given
+      # URL
       def annotations_for_url(url)
         url = sanitize_sparql(url).to_uri
         select_annotations([:note, N::SWICKY.refersTo, url])
       end
-      
+
+      def annotations_for_image(url)
+        url = sanitize_sparql(url).to_uri
+        select_annotations([:note, N::SWICKY.refersTo, :fragment], [:fragment, N::DISCOVERY.isPartOf, url])
+        # result = []
+        # url = sanitize_sparql(url).to_uri
+        # q = ActiveRDF::Query.new(N::URI).select(:fragment).distinct.where(:fragment, N::DISCOVERY.isPartOf, url)
+        # q.execute.each do |fragment|
+        #   result = {fragment.uri.to_s => {}}
+        #   q2 = ActiveRDF::Query.new(N::URI).select(:predicate, :object).distinct
+        #   q2.where fragment, :predicate, :object
+        #   q2.execute.each do |predicate, object|
+        #     result[fragment.uri.to_s][predicate.to_s] = object.to_s
+        #   end
+        # end
+        # result
+      end
+
+      # Select all the annotations on the note that uses the fragment identified by the given XPOINTER
+      # string
       def annotations_for_xpointer(xpointer)
         xpointer = sanitize_sparql(xpointer).to_uri
         select_annotations([:note, N::SWICKY.refersTo, :fragment], [:fragment, N::SWICKY.hasCoordinates, xpointer])
@@ -99,16 +149,33 @@ module Swicky
       
       private
       
+      # Select annotation triples. This expects an array of "where" conditions (that is, arrays with a 
+      # subject-predicate-object pattern). One of the conditions must match a :note variable.
+      # 
+      # This will return all triples where:
+      # 
+      # * :note is the subject of the triple
+      # * That have :statement as their subject, and :statement is a statement on one of the notes above
+      # * That have any of the predicates or objects of the results above as their subject
       def select_annotations(*note_matching)
         # Select all triples on the notes
         note_triples_qry = ActiveRDF::Query.new(N::URI).select(:note, :predicate, :object).distinct
         note_matching.each { |conditions| note_triples_qry.where(*conditions) }
-        note_triples = note_triples_qry.where(:note, :predicate, :object).execute
+        result_triples = note_triples_qry.where(:note, :predicate, :object).execute
+        # Select all on the fragments of the note
+        fragment_triples_qry = ActiveRDF::Query.new(N::URI).select(:fragment, :predicate, :object).distinct
+        note_matching.each { |conditions| fragment_triples_qry.where(*conditions) }
+        fragment_triples_qry.where(:note, N::SWICKY.refersTo, :fragment)
+        fragment_triples_qry.where(:fragment, :predicate, :object)
+        result_triples += fragment_triples_qry.execute
         # Select all statements on the triples
         statement_triples_qry = ActiveRDF::Query.new(N::URI).select(:statement, :predicate, :object).distinct
         note_matching.each { |conditions| statement_triples_qry.where(*conditions) }
-        statement_triples_qry.where(:note, N::SWICKY.hasStatement, :statement).where(:statement, :predicate, :object)
-        result_triples = note_triples + statement_triples_qry.execute
+        statement_triples_qry.where(:note, N::SWICKY.refersTo, :fragment)
+        statement_triples_qry.where(:fragment, N::SWICKY.hasStatement, :statement)
+        statement_triples_qry.where(:statement, :predicate, :object)
+
+        result_triples += statement_triples_qry.execute
         # TODO: Fix this to better query once available in ActiveRDF
         additional_triples = []
         result_triples.each do |trip|
@@ -117,7 +184,6 @@ module Swicky
             additional_triples += ActiveRDF::Query.new(N::URI).select(:predicate, :object).distinct.where(trip.last, :predicate, :object).execute.collect { |result| [trip.last] + result }
           end
         end
-        
         # Return all results
         result_triples + additional_triples
       end
@@ -125,4 +191,4 @@ module Swicky
     end
     
   end
-end
+end

data/lib/talia_core/active_source.rb

@@ -28,7 +28,7 @@ module TaliaCore
     extend ActiveSourceParts::SqlHelper
     include ActiveSourceParts::PredicateHandler
     extend ActiveSourceParts::PredicateHandler::ClassMethods
-    include ActiveSourceParts::Rdf
+    include ActiveSourceParts::RdfHandler
     extend TaliaUtil::Progressable # Progress for import methods on class
     
     # Set the handlers for the callbacks defined in the other modules. The
@@ -36,6 +36,8 @@ module TaliaCore
     after_update :auto_update_rdf
     after_create :auto_create_rdf
     after_save :save_wrappers # Save the cache wrappers
+    before_destroy :destroy_dependent_props
+    after_destroy :clear_rdf
 
     
     # Relations where this source is the subject of the triple
@@ -97,6 +99,8 @@ module TaliaCore
     def [](attribute)
       if(db_attr?(attribute))
         super(attribute)
+      elsif(defined_property?(attribute))
+        self.send(attribute)
       else
         get_objects_on(attribute)
       end
@@ -107,10 +111,10 @@ module TaliaCore
     def []=(attribute, value)
       if(db_attr?(attribute))
         super(attribute, value)
+      elsif(defined_property?(attribute))
+        self.send("#{attribute}=", value)
       else
-        pred = get_attribute(attribute)
-        pred.remove
-        pred << value
+         get_wrapper_on(attribute).replace(value)
       end
     end
 
@@ -176,7 +180,7 @@ module TaliaCore
       super(process_attributes(false, attributes))
     end
 
-    # As update_attributes, but uses save! to save the source
+    # As update_attributes, but uses save! to save the source 
     def update_attributes!(attributes)
       yield self if(block_given?)
       super(process_attributes(false, attributes))
@@ -204,10 +208,13 @@ module TaliaCore
     # the attribute values will be added to the existing ones
     def add_semantic_attributes(overwrite, attributes)
       attributes.each do |attr, value|
-        value = [ value ] unless(value.is_a?(Array))
-        attr_wrap = self[attr]
-        attr_wrap.remove if(overwrite)
-        value.each { |val |self[attr] << target_for(val) }
+        if(defined_property?(attr))
+          self[attr] = value
+        else
+          attr_wrap = self[attr]
+          attr_wrap.remove if(overwrite)
+          value.to_a.each { |val| self[attr] << target_for(val) }
+        end
       end
     end
 
@@ -280,6 +287,14 @@ module TaliaCore
     def db_attr?(attribute)
       ActiveSource.db_attr?(attribute)
     end
+    
+    def defined_property?(prop_name)
+      self.class.defined_property?(prop_name)
+    end
+    
+    def property_options_for(property)
+      self.class.property_options_for(property)
+    end
 
     # Writes the predicate directly to the database and the rdf store. The
     # Source does not need to be saved and no data is loaded from the database.
@@ -348,9 +363,10 @@ module TaliaCore
     def attach_files(files)
       files = [ files ] unless(files.is_a?(Array))
       files.each do |file|
-        filename = file[:url] || file['url']
+        file.to_options!
+        filename = file[:url]
         assit(filename)
-        options = file[:options] || file['options'] || {}
+        options = file[:options] || {}
         records = DataTypes::FileRecord.create_from_url(filename, options)
         records.each { |rec| self.data_records << rec }
       end
@@ -373,14 +389,30 @@ module TaliaCore
     def rdf_selftype
       (N::TALIA + self.class.name.demodulize)
     end
-    
+
+    def reload
+      reset! # Clear the property cache
+      super
+    end
+
     private
     
+    # Removes dependent properties
+    def destroy_dependent_props
+      self.class.props_to_destroy.each do |prop|
+        values = self[prop]
+        values = [values] unless(values.is_a?(SemanticCollectionWrapper))
+        values.each do |val|
+          val.destroy if(val.is_a?(TaliaCore::ActiveSource))
+        end
+      end
+    end
+    
     # Extracts the semantic attributes from the attribute hash and passes them
     # to add_semantic_attributes with the given overwrite flag.  
     # The database attributes are returned by the method
     def process_attributes(overwrite, attributes)
-      attributes = ActiveSource.split_attribute_hash(attributes)
+      attributes = self.class.split_attribute_hash(attributes)
       add_semantic_attributes(overwrite, attributes[:semantic_attributes])
       attributes[:db_attributes]
     end

data/lib/talia_core/active_source_parts/class_methods.rb

@@ -1,8 +1,16 @@
 module TaliaCore
   module ActiveSourceParts
+
+    # Class methods for ActiveSource:
+    #
+    # * Property definitions for source classes (singular_property, multi_property, manual_property)
+    # * Logic for the creation of new sources, and things like exists?
+    # * "Import" methods for the class: create_from_xml, create_multi_from
+    # * autofill_uri logic
+    # * Various utility method
     module ClassMethods
 
-      # Accessor for addtional rdf types that will automatically be added to each
+      # Accessor for additional rdf types that will automatically be added to each
       # object of that Source class
       def additional_rdf_types 
         @additional_rdf_types ||= []
@@ -24,7 +32,12 @@ module TaliaCore
 
           # We have an option hash to init the source
           files = options.delete(:files)
-          options[:uri] = uri_string_for(options[:uri])
+          options[:uri] = uri_string_for(options[:uri], false)
+          if(autofill_overwrites?)
+            options[:uri] = auto_uri
+          elsif(autofill_uri?)
+            options[:uri] ||= auto_uri
+          end
           attributes = split_attribute_hash(options)
           the_source = super(attributes[:db_attributes])
           the_source.add_semantic_attributes(false, attributes[:semantic_attributes])
@@ -33,6 +46,10 @@ module TaliaCore
         elsif(args.size == 1 && ( uri_s = uri_string_for(args[0]))) # One string argument should be the uri
           # Either the current object from the db, or a new one if it doesn't exist in the db
           find(:first, :conditions => { :uri => uri_s } ) || super(:uri => uri_s)
+        elsif(args.size == 0 && autofill_uri?)
+          auto = auto_uri
+          raise(ArgumentError, "Record already exists #{auto}") if(ActiveSource.exists?(auto))
+          super(:uri => auto)
         else
           # In this case, it's a generic "new" call
           super
@@ -41,6 +58,7 @@ module TaliaCore
         the_source
       end
 
+
       # Retrieves a new source with the given type. This gets a propety hash
       # like #new, but it will correctly initialize a source of the type given
       # in the hash. If no type is given, this will create a plain ActiveSource.
@@ -97,7 +115,7 @@ module TaliaCore
             props.to_options!
             src = nil
             begin
-              props[:uri] = uri_string_for(props[:uri])
+              props[:uri] = uri_string_for(props[:uri], false)
               assit(props[:uri], "Must have a valid uri at this step")
               if(src = ActiveSource.find(:first, :conditions => { :uri => props[:uri] }))
                 src.update_source(props, options[:duplicates])
@@ -107,7 +125,7 @@ module TaliaCore
               src.save!
             rescue Exception => e
               if(options[:errors]) 
-                err = ImportError.new("ERROR during import of #{props[:uri]}: #{e.message}")
+                err = Errors::ImportError.new("ERROR during import of #{props[:uri]}: #{e.message}")
                 err.set_backtrace(e.backtrace)
                 options[:errors] <<  err
                 TaliaCore.logger.warn("Problems importing #{props[:uri]} (logged): #{e.message}")
@@ -142,7 +160,7 @@ module TaliaCore
       end
 
       # Like update, only that it will overwrite the given attributes instead
-      # of adding to them
+      # of adding to themƒ
       def rewrite(id, attributes)
         record = find(id)
         raise(ActiveRecord::RecordNotFound) unless(record)
@@ -200,6 +218,8 @@ module TaliaCore
         attributes.each do |field, value|
           if(db_attr?(field))
             db_attributes[field] = value
+          elsif(defined_property?(field))
+            semantic_attributes[field] = value
           else
             semantic_attributes[expand_uri(field)] = value
           end
@@ -207,8 +227,37 @@ module TaliaCore
         { :semantic_attributes => semantic_attributes, :db_attributes => db_attributes }
       end
 
+      def property_options_for(property)
+        property = defined_props[property.to_s] if(defined_props[property.to_s])
+        this_options = my_property_options[property.to_s]
+        parent_options = superclass.try_call.property_options_for(property)
+        if(this_options && parent_options)
+          parent_options.merge(this_options)
+        else
+          this_options || parent_options || {}
+        end
+      end
+
+      def defined_property?(prop_name)
+        defined_props.include?(prop_name.to_s) || superclass.try_call.defined_property?(prop_name.to_s)
+      end
+
+      # All the options that should be destroy for :dependent => :destroy settings
+      def props_to_destroy
+        to_destroy = (superclass.try_call.props_to_destroy || [])
+        my_property_options.each do |prop, options|
+          to_destroy << prop if(options[:dependent] == :destroy)
+        end
+        to_destroy
+      end
+
       private
 
+      # Make URL for autofilling
+      def auto_uri
+        (N::LOCAL + self.name.tableize + "/#{rand Time.now.to_i}").to_s
+      end
+
       # The attributes stored in the database
       def db_attributes
         @db_attributes ||= (ActiveSource.new.attribute_names << 'id')
@@ -221,33 +270,73 @@ module TaliaCore
         types.each { |t| @additional_rdf_types << t.to_s }
       end
 
+      # Class helper to declare that this Source model is allowed to automatically
+      # create uri values for new elements. In that case, the model will
+      # automatically assign a URL to all new records to which no url value has
+      # been passed.
+      #
+      # If the :force option is set, the autofill will overwrite an existing uri that
+      # is passed in during creation.
+      def autofill_uri(options = {})
+        options.to_options!
+        options.assert_valid_keys(:force)
+        @can_autofill = true
+        @autofill_overwrites = options[:force]
+      end
+
+      def autofill_uri?
+        @can_autofill
+      end
+
+      def autofill_overwrites?
+        @autofill_overwrites
+      end
+
+      
+      def singular_property(prop_name, property, options = {})
+        define_property(prop_name, property, options.merge(:singular_property => true))
+      end
+
+
+      # Defines a multi-value property in the same way as #singular_property
+      def multi_property(prop_name, property, options = {})
+        define_property(prop_name, property, options.merge(:singular_property => false))
+      end
+
+      # Defines a "manual" property. This means that getters and setters are provided
+      # by the user and this statement only declares that the system may autoassign to
+      # that property
+      def manual_property(prop_name)
+        defined_props[prop_name.to_s] = :manual
+      end
+
       # Helper to define a "singular accessor" for something (e.g. siglum, catalog)
       # This accessor will provide an "accessor" method that returns the
       # single property value directly and an assignment method that replaces
       # the property with the value.
       #
+      # A find_by_<property> finder method is also created.
+      #
       # The Source will cache newly set singular properties internally, so that
       # the new value is immediately reflected on the object. However, the
       # change will only be made permanent on #save! - and saving will also clear
       # the cache
-      def singular_property(prop_name, property)
+      #      
+      #  [*:dependent*] You may pass :dependend => :destroy as for ActiveRecord relations
+      def define_property(prop_name, property, options = {})
         prop_name = prop_name.to_s
-        @singular_props ||= []
-        return if(@singular_props.include?(prop_name))
+        property_options(property, options) # Save options for the current property
+
+        return if(defined_props.include?(prop_name))
         raise(ArgumentError, "Cannot overwrite method #{prop_name}") if(self.instance_methods.include?(prop_name) || self.instance_methods.include?("#{prop_name}="))
+
         # define the accessor
         define_method(prop_name) do
-          prop = self[property]
-          assit_block { |err| (prop.size > 1) ? err << "Must have at most 1 value for singular property #{prop_name} on #{self.uri}. Values #{self[property]}" : true }
-          prop.size > 0 ? prop[0] : nil
+          self[property]
         end
 
         # define the writer
-        define_method("#{prop_name}=") do |value|
-          prop = self[property]
-          prop.remove
-          prop << value
-        end
+        define_writer(prop_name, property)
 
         # define the finder
         (class << self ; self; end).module_eval do
@@ -258,31 +347,70 @@ module TaliaCore
             find(:all, finder)
           end
         end
+        defined_props[prop_name] = property
+      end
 
-        @singular_props << prop_name
-        true
+      # Helper to dynamically define the singular or multi-value assignment accessor
+      def define_writer(prop_name, property)
+        define_method("#{prop_name}=") do |values|
+          self[property] = values
+        end
       end
 
-      # Helper to creat an accessor for the given predicate. This will shortcut
-      # the prop_name method to self[property]
-      def simple_property(prop_name, property)
-        define_method(prop_name) do
-          self[property]
+      # The hash containing the mapping between defined property names and the 
+      # RDF properties on which they are defined.
+      def defined_props
+        @defined_props ||= {}
+      end
+
+      # Hash that contains all options that are defined for the properties
+      def my_property_options
+        @my_property_options ||= {}
+      end
+
+      # Sets the options for handling semantic relations/properties with the predicate
+      # #property. The options are:
+      #
+      #  [*force_relation*] Forces the the values to be relations. This means that
+      #                      each and every value passed to the generated accessors
+      #                      will be interpreted as a URL. *DEPRECATED*, use
+      #                      `:type => TaliaCore::ActiveSource` instead
+      #  [*type*] Declare that the values of this property should be of the given
+      #            type, which should be a Ruby runtime class or a symbol corresponding
+      #            to an ActiveRecord field type. If this is an ActiveSource subclass,
+      #            this will force all values that are passed to this property
+      #            to be interpreted as the URI of an ActiveSource (if the value is not
+      #            an ActiveSource already)
+      #  [*singular_property*] 
+      #            be used to force each value passed to the accessors, #new and
+      #            #update* will be interpreted as the uri of a source of the given type,
+      #
+      def property_options(property, options)
+        options.to_options!
+        options.assert_valid_keys(:force_relation, :dependent, :type, :singular_property)
+        if(force = options.delete(:force_relation).true?)
+          warn("Deprecation Warning: :force_relation is deprecated - use ':type => TaliaCore::ActiveSource' instead")
+          options[:type] ||= ActiveSource
         end
+        my_property_options[property.to_s] ||= {}
+        my_property_options[property.to_s].merge!(options)
       end
 
       # This gets the URI string from the given value. This will just return
       # the value if it's a string. It will return the result of value.uri, if
       # that method exists; otherwise it'll return nil
-      def uri_string_for(value)
+      #
+      # If the id_aware flag is set this will return nil for any uri string that
+      # appears to be a numeric id.
+      def uri_string_for(value, id_aware = true)
         result = if value.is_a? String
-          return nil if(value  =~ /\A\d+(-.*)?\Z/) # This looks like a record id or record param, encoded as a string
+          return nil if((value  =~ /\A\d+(-.*)?\Z/) && id_aware) # This looks like a record id or record param, encoded as a string
           # if this is a local name, prepend the local namespace
           (value =~ /:/) ? value : (N::LOCAL + value).uri
         elsif(value.respond_to?(:uri))
           value.uri
         else
-          nil
+          id_aware ? nil : value
         end
         result = result.to_s if result
         result