active-fedora 3.3.2 → 4.0.0.rc1

data/lib/active_fedora/config.rb

@@ -0,0 +1,38 @@
+module ActiveFedora 
+  class Config
+    attr_reader :path, :credentials
+    def initialize(config_path, env)
+      @path = config_path
+      val = YAML.load(File.open(config_path))[env]
+      if val.is_a? Array
+        init_shards(val)
+      else 
+        init_single(val)
+      end
+    end
+
+    def sharded?
+      credentials.is_a? Array
+    end
+
+    private
+
+    def init_shards(vals)
+        @credentials = vals.map(&:symbolize_keys)
+    end
+
+    def init_single(vals)
+        @credentials = vals.symbolize_keys
+        if @credentials[:url] && !@credentials[:user]
+          ActiveSupport::Deprecation.warn("Using \":url\" in the fedora.yml file without :user and :password is no longer supported") 
+          u = URI.parse @credentials[:url]
+          @credentials[:user] = u.user
+          @credentials[:password] = u.password
+          @credentials[:url] = "#{u.scheme}://#{u.host}:#{u.port}#{u.path}"
+        end
+        unless @credentials.has_key?(:user) && @credentials.has_key?(:password) && @credentials.has_key?(:url)
+          raise ActiveFedora::ConfigurationError, "You must provide user, password and url in the #{env} section of #{@path}"
+        end
+    end
+  end
+end

data/lib/active_fedora/content_model.rb

@@ -11,12 +11,6 @@ module ActiveFedora
       super
     end
     
-    # @deprecated Please use {.to_class_uri} instead
-    def self.pid_from_ruby_class(klass,attrs={})
-      ActiveSupport::Deprecation.warn("pid_from_ruby_class is deprecated.  Use klass.to_class_uri instead")
-      klass.to_class_uri(attrs)
-    end
-    
     ###Override this, if you prefer your class names serialized some other way
     def self.sanitized_class_name(klass)
       klass.name.gsub(/(::)/, '_')

data/lib/active_fedora/datastream.rb

@@ -93,6 +93,28 @@ module ActiveFedora
       return true
     end
     
+    def solrize_profile(solr_doc = Hash.new) # :nodoc:
+      profile.each_pair do |property,value|
+        if property =~ /Date/
+          value = Time.parse(value) unless value.is_a?(Time)
+          value = value.xmlschema
+        end
+        solr_doc[ActiveFedora::SolrService.solr_name("#{dsid}_dsProfile_#{property}", property =~ /Date/ ? :date : :symbol)] = value
+      end
+      solr_doc
+    end
+    
+    def from_solr(solr_doc)
+      profile_from_solr(solr_doc)
+    end
+    
+    def profile_from_solr(solr_doc)
+      profile_attrs = solr_doc.keys.select { |k| k =~ /^#{dsid}_dsProfile_/ }
+      profile_attrs.each do |key|
+        attr_name = key.split(/_/)[2..-2].join('_')
+        profile[attr_name] = solr_doc[key].to_s
+      end
+    end
   end
   
   class DatastreamConcurrencyException < Exception # :nodoc:

data/lib/active_fedora/delegating.rb

@@ -1,7 +1,7 @@
 module ActiveFedora
   module Delegating
     extend ActiveSupport::Concern
-
+    
     module ClassMethods
       # Provides a delegate class method to expose methods in metadata streams
       # as member of the base object. Pass the target datastream via the 
@@ -26,33 +26,32 @@ module ActiveFedora
         create_delegate_accessor(field, args)
         create_delegate_setter(field, args)
       end
-
+      
       private
-        def create_delegate_accessor(field, args)
-            define_method field do
-              ds = self.send(args[:to])
-              val = if ds.kind_of?(ActiveFedora::MetadataDatastream) || ds.kind_of?(ActiveFedora::DCRDFDatastream)
-                ds.send(:get_values, field)
-              else 
-                terminology = args[:at] || [field]
-                ds.send(:term_values, *terminology)
-              end 
-              args[:unique] ? val.first : val
-                
-            end
+      def create_delegate_accessor(field, args)
+        define_method field do
+          ds = self.send(args[:to])
+          val = if ds.kind_of?(ActiveFedora::MetadataDatastream) || ds.kind_of?(ActiveFedora::RDFDatastream)
+                  ds.send(:get_values, field)
+                else 
+                  terminology = args[:at] || [field]
+                  ds.send(:term_values, *terminology)
+                end
+          args[:unique] ? val.first : val
         end
-
-        def create_delegate_setter(field, args)
-            define_method "#{field}=".to_sym do |v|
-              ds = self.send(args[:to])
-              if ds.kind_of?(ActiveFedora::MetadataDatastream) || ds.kind_of?(ActiveFedora::DCRDFDatastream)
-                ds.send(:set_value, field, v)
-              else 
-                terminology = args[:at] || [field]
-                ds.send(:update_indexed_attributes, {terminology => v})
-              end
-            end
+      end
+      
+      def create_delegate_setter(field, args)
+        define_method "#{field}=".to_sym do |v|
+          ds = self.send(args[:to])
+          if ds.kind_of?(ActiveFedora::MetadataDatastream) || ds.kind_of?(ActiveFedora::RDFDatastream)
+            ds.send(:set_value, field, v)
+          else 
+            terminology = args[:at] || [field]
+            ds.send(:update_indexed_attributes, {terminology => v})
+          end
         end
+      end
     end
   end
 end

data/lib/active_fedora/digital_object.rb

@@ -4,7 +4,8 @@ module ActiveFedora
     attr_accessor :original_class
     
     def self.find(original_class, pid)
-      obj = super(pid, RubydoraConnection.instance.connection)
+      conn = original_class.connection_for_pid(pid)
+      obj = super(pid, conn)
       obj.original_class = original_class
       obj
     end

data/lib/active_fedora/file_management.rb

@@ -3,6 +3,7 @@ module ActiveFedora
     extend ActiveSupport::Concern
 
     included do
+      include ActiveFedora::Relationships
       has_relationship "collection_members", :has_collection_member
       has_relationship "part_of", :is_part_of
       has_bidirectional_relationship "parts", :has_part, :is_part_of

data/lib/active_fedora/fixture_exporter.rb

@@ -24,7 +24,7 @@ module ActiveFedora
         end
       end
 
-      RubydoraConnection.instance.connection.export(:pid=>pid, :format=>format, :context=>extra_params[:context].to_s)
+      ActiveFedora::Base.connection_for_pid(pid).export(:pid=>pid, :format=>format, :context=>extra_params[:context].to_s)
     end
 
 

data/lib/active_fedora/fixture_loader.rb

@@ -26,7 +26,7 @@ module ActiveFedora
     end
 
     def import_and_index(pid)
-      body = self.class.import_to_fedora(filename_for_pid(pid))
+      body = self.class.import_to_fedora(filename_for_pid(pid), pid)
       self.class.index(pid)
       body
     end
@@ -36,9 +36,9 @@ module ActiveFedora
         solrizer.solrize(pid) 
     end
 
-    def self.import_to_fedora(filename)
+    def self.import_to_fedora(filename, pid)
       file = File.new(filename, "r")
-      result = ActiveFedora::RubydoraConnection.instance.connection.ingest(:file=>file.read)
+      result = ActiveFedora::Base.connection_for_pid(pid).ingest(:file=>file.read)
       raise "Failed to ingest the fixture." unless result
       result.body
     end

data/lib/active_fedora/metadata_datastream.rb

@@ -40,7 +40,12 @@ module ActiveFedora
     #
     # ====Warning
     #  Solr must be synchronized with data in Fedora.
+    #  @content is initialized to the empty document template to satisfy #ensure_xml_loaded
+    #    (called from #update_attributes and #update_indexed_attributes)
     def from_solr(solr_doc)
+      @content = self.to_xml
+      self.xml_loaded = true
+      profile_from_solr(solr_doc)
       fields.each do |field_key, field_info|
         field_symbol = ActiveFedora::SolrService.solr_name(field_key, field_info[:type])
         value = (solr_doc[field_symbol].nil? ? solr_doc[field_symbol.to_s]: solr_doc[field_symbol]) 
@@ -241,6 +246,7 @@ module ActiveFedora
     #you will end up replicating the values in the underlying datastream, resulting in mysterious dubling, quadrupling, etc. 
     #whenever you edit the field's values.
     def field(name, tupe, opts={})
+      #TODO add term to terminology
       @fields[name.to_s.to_sym]={:type=>tupe, :values=>[]}.merge(opts)
       eval <<-EOS
         def #{name}_values=(arg)

data/lib/active_fedora/model.rb

@@ -21,6 +21,7 @@ module ActiveFedora
     # Takes a Fedora URI for a cModel, and returns a 
     # corresponding Model if available
     # This method should reverse ClassMethods#to_class_uri
+    # @return [Class, False] the class of the model or false, if it does not exist
     def self.from_class_uri(uri)
       model_value, pid_ns = classname_from_uri(uri)
       raise "model URI incorrectly formatted: #{uri}" unless model_value
@@ -79,8 +80,21 @@ module ActiveFedora
       # @example this will return an instance of Book, even if the object hydra:dataset1 asserts that it is a Dataset
       #   Book.load_instance("hydra:dataset1") 
       def load_instance(pid)
-        RubydoraConnection.instance.find_model(pid, self)
+        self.allocate.init_with(DigitalObject.find(self, pid))
       end
+ 
+      # Retrieve the Fedora object with te given pid, explore the returned object, determine its model 
+      # using #{known_models_for} and cast to that class.
+      # @param [String] pid of the object to load
+      #
+      # @example because the object hydra:dataset1 asserts it is a Dataset (hasModel info:fedora/afmodel:Dataset), return a Dataset object (not a Book).
+      #   Book.find_document("hydra:dataset1") 
+      def find_document(pid)
+        af_base = load_instance(pid)
+        the_model = ActiveFedora::ContentModel.known_models_for( af_base ).first
+        af_base.adapt_to(the_model)
+      end
+
       
       # Returns a suitable uri object for :has_model
       # Should reverse Model#from_class_uri
@@ -103,20 +117,25 @@ module ActiveFedora
       # called on
       def find(args, opts={})
         opts = {:rows=>25}.merge(opts)
-        return_multiple = false
         if args == :all
-          return_multiple = true
           escaped_class_uri = SolrService.escape_uri_for_query(self.to_class_uri)
           q = "#{ActiveFedora::SolrService.solr_name(:has_model, :symbol)}:#{escaped_class_uri}"
           hits = SolrService.instance.conn.query(q, :rows=>opts[:rows]).hits 
           return hits.map do |hit|
-             RubydoraConnection.instance.find_model(hit[SOLR_DOCUMENT_ID], self)
+             pid = hit[SOLR_DOCUMENT_ID]
+             load_instance(pid)
           end
         elsif args.class == String
-          return RubydoraConnection.instance.find_model(args, self)
+          return load_instance(args)
         end
       end
 
+      def find_model(pid)
+        ActiveSupport::Deprection.warn("find_model is deprecated.  Use load_instance instead")
+        load_instance(pid)
+      end
+
+
       # Get a count of the number of objects from solr
       # Takes :conditions as an argument
       def count(args = {})

data/lib/active_fedora/nokogiri_datastream.rb

@@ -100,6 +100,7 @@ module ActiveFedora
     # 
     # See ActiveFedora::Base.load_instance_from_solr and +get_values_from_solr+ for more information.
     def from_solr(solr_doc)
+      profile_from_solr(solr_doc)
       #just initialize internal_solr_doc since any value retrieval will be done via lazy loading on this doc on-demand
       @internal_solr_doc = solr_doc
     end

data/lib/active_fedora/ntriples_rdf_datastream.rb

@@ -2,7 +2,6 @@ require 'rdf/ntriples'
 
 module ActiveFedora
   class NtriplesRDFDatastream < RDFDatastream
-
     def serialization_format
       :ntriples
     end

data/lib/active_fedora/persistence.rb

@@ -91,8 +91,9 @@ module ActiveFedora
       persist
     end
 
+    # replace the unsaved digital object with a saved digital object
     def assign_pid
-      @inner_object = @inner_object.save #replace the unsaved digital object with a saved digital object
+      @inner_object = @inner_object.save 
     end
     
     # Pushes the object and all of its new or dirty datastreams into Fedora

data/lib/active_fedora/predicates.rb

@@ -1,41 +1,41 @@
 module ActiveFedora
-
   module Predicates
     def self.find_graph_predicate(predicate)
-        #TODO, these could be cached
-        case predicate
-        when :has_model, "hasModel", :hasModel
-          xmlns="info:fedora/fedora-system:def/model#"
-          begin
-            rel_predicate = predicate_lookup(predicate,xmlns)
-          rescue UnregisteredPredicateError
-            xmlns = nil
-            rel_predicate = nil
-          end
-        else
-          xmlns="info:fedora/fedora-system:def/relations-external#"
-          begin
-            rel_predicate = predicate_lookup(predicate,xmlns)
-          rescue UnregisteredPredicateError
-            xmlns = nil
-            rel_predicate = nil
-          end
+      #TODO, these could be cached
+      case predicate
+      when :has_model, "hasModel", :hasModel
+        xmlns="info:fedora/fedora-system:def/model#"
+        begin
+          rel_predicate = predicate_lookup(predicate,xmlns)
+        rescue UnregisteredPredicateError
+          xmlns = nil
+          rel_predicate = nil
         end
-        
-        unless xmlns && rel_predicate
-          rel_predicate, xmlns = find_predicate(predicate)
+      else
+        xmlns="info:fedora/fedora-system:def/relations-external#"
+        begin
+          rel_predicate = predicate_lookup(predicate,xmlns)
+        rescue UnregisteredPredicateError
+          xmlns = nil
+          rel_predicate = nil
         end
-        vocabularies[xmlns][rel_predicate] 
+      end
+        
+      unless xmlns && rel_predicate
+        rel_predicate, xmlns = find_predicate(predicate)
+      end
+
+      vocabularies[xmlns][rel_predicate] 
     end
 
     def self.vocabularies
-      return @vocabularies if @vocabularies
-      @vocabularies = {}
-      predicate_mappings.keys.each { |ns| @vocabularies[ns] = RDF::Vocabulary.new(ns)}
+      @vocabularies ||= {}
+      predicate_mappings.keys.each do |ns| 
+        @vocabularies[ns] = RDF::Vocabulary.new(ns) unless @vocabularies.has_key? ns
+      end
       @vocabularies
     end
 
-
     # If predicate is a symbol, looks up the predicate in the predicate_mappings
     # If predicate is not a Symbol, returns the predicate untouched
     # @raise UnregisteredPredicateError if the predicate is a symbol but is not found in the predicate_mappings

data/lib/active_fedora/rdf_datastream.rb

@@ -2,6 +2,72 @@ require 'rdf'
 
 module ActiveFedora
   class RDFDatastream < Datastream
+    module ModelMethods
+      extend ActiveSupport::Concern
+      module ClassMethods
+        def config
+          ActiveFedora::Predicates.predicate_config
+        end
+        def map_predicates(&block)
+          yield self
+        end
+        def method_missing(name, *args)
+          args = args.first if args.respond_to? :first
+          raise "mapping must specify RDF vocabulary as :in argument" unless args.has_key? :in
+          vocab = args[:in]
+          predicate = args.fetch(:to, name)
+          raise "Vocabulary '#{vocab.inspect}' does not define property '#{predicate.inspect}'" unless vocab.respond_to? predicate
+          vocab = vocab.to_s
+          if config 
+            if config[:predicate_mapping].has_key? vocab
+              config[:predicate_mapping][vocab][name] = predicate
+            else
+              config[:predicate_mapping][vocab] = { name => predicate }
+           end
+          else
+            config = {
+              :default_namespace => vocab,
+              :predicate_mapping => {
+                vocab => { name => predicate }
+              }
+            }
+          end
+        end
+      end
+    end
+
+    class TermProxy
+      # @param [Symbol, RDF::URI] predicate  the predicate to insert into the graph
+      # @param [ActiveFedora::RelationshipGraph] graph  the graph
+      include Enumerable
+      def initialize(graph, predicate, values=[])
+        @graph = graph
+        @predicate = predicate
+        @values = values
+      end
+      def each(&block)
+        @values.each { |value| block.call(value)}
+      end
+      def <<(*values)
+        @values.concat(values)
+        values.each { |value| @graph.add(@predicate, value, true) }
+        @graph.dirty = true
+        @values
+      end
+      def ==(other)
+        other.inspect == @values.inspect
+      end
+      def delete(*values)
+        values.each do |value| 
+          res = @values.delete(value)
+          @graph.delete(@predicate, value) unless res.nil?
+          @graph.dirty = true
+        end
+        @values
+      end
+    end
+    
+    include ModelMethods
     attr_accessor :loaded
 
     def ensure_loaded
@@ -19,66 +85,79 @@ module ActiveFedora
       end
     end
 
+    # @param [Symbol, RDF::URI] predicate  the predicate to insert into the graph
+    def find_predicate(predicate)
+      predicate = predicate.to_sym unless predicate.kind_of? RDF::URI
+      result = ActiveFedora::Predicates.find_predicate(predicate)
+      return RDF::URI(result.reverse.to_s)
+    end
+
     def graph
       @graph ||= RelationshipGraph.new
     end
 
+    # @param [Symbol, RDF::URI] predicate  the predicate to insert into the graph
     def get_values(predicate)
       ensure_loaded
-      predicate = resolve_predicate(predicate) unless predicate.kind_of? RDF::URI
+      predicate = find_predicate(predicate) unless predicate.kind_of? RDF::URI
       results = graph[predicate]
-      res = []
+      return if results.nil?
+      values = []
       results.each do |object|
-        res << (object.kind_of?(RDF::Literal) ? object.value : object.to_str)
+        values << (object.kind_of?(RDF::Literal) ? object.value : object.to_str)
       end
-      res
+      TermProxy.new(graph, predicate, values)
+    end
+
+    def to_solr
+      # TODO
     end
-  
+
     # if there are any existing statements with this predicate, replace them
+    # @param [Symbol, RDF::URI] predicate  the predicate to insert into the graph
     def set_value(predicate, args)
       ensure_loaded
-      predicate = resolve_predicate(predicate) unless predicate.kind_of? RDF::URI
+      predicate = find_predicate(predicate) unless predicate.kind_of? RDF::URI
       graph.delete(predicate)
-      graph.add(predicate, args, true)
+      args.each do |arg|
+        graph.add(predicate, arg, true)
+      end
+      graph.dirty = true
+      return TermProxy.new(graph, predicate, args)
     end
 
     # append a value 
+    # @param [Symbol, RDF::URI] predicate  the predicate to insert into the graph
     def append(predicate, args)
       ensure_loaded
+      predicate = find_predicate(predicate) unless predicate.kind_of? RDF::URI
       graph.add(predicate, args, true)
+      graph.dirty = true
+      return TermProxy.new(graph, predicate, args)
     end
 
-
+    def serialization_format
+      raise "you must override the `serialization_format' method in a subclass"
+    end
 
     def method_missing(name, *args)
-      if pred = resolve_predicate(name) 
-        get_values(pred)
-      elsif (md = /^([^=]+)=$/.match(name.to_s)) && pred = resolve_predicate(md[1])
+      if (md = /^([^=]+)=$/.match(name.to_s)) && pred = find_predicate(md[1])
         set_value(pred, *args)  
+       elsif pred = find_predicate(name)
+        get_values(name)
       else 
         super
       end
     end
-
-    def serialization_format
-      raise "you must override the `serialization_format' method in a subclass"
-    end
-
     
-    # given a symbol or string, map it to a RDF::URI
-    # if the provided parameter is not allowed in the vocabulary, return nil
-    def resolve_predicate(predicate)
-      raise "you must override the `resolve_predicate' method in a subclass"
-    end
-
     # Populate a RDFDatastream object based on the "datastream" content 
     # Assumes that the datastream contains RDF XML from a Fedora RELS-EXT datastream 
-    # @param [ActiveFedora::MetadataDatastream] tmpl the Datastream object that you are populating
-    # @param [String] the "rdf" node 
+    # @param [String] data the "rdf" node 
     def deserialize(data) 
       unless data.nil?
         RDF::Reader.for(serialization_format).new(data) do |reader|
           reader.each_statement do |statement|
+            next unless statement.subject == "info:fedora/#{pid}"
             literal = statement.object.kind_of?(RDF::Literal)
             object = literal ? statement.object.value : statement.object.to_str
             graph.add(statement.predicate, object, literal)
@@ -89,10 +168,8 @@ module ActiveFedora
     end
 
     # Creates a RDF datastream for insertion into a Fedora Object
-    # @param [String] pid
-    # @param [Hash] relationships (optional) @default self.relationships
     # Note: This method is implemented on SemanticNode instead of RelsExtDatastream because SemanticNode contains the relationships array
-    def serialize()
+    def serialize
       out = RDF::Writer.for(serialization_format).buffer do |writer|
         graph.to_graph("info:fedora/#{pid}").each_statement do |statement|
           writer << statement
@@ -100,9 +177,6 @@ module ActiveFedora
       end
       out
     end
-    
-    
   end
-
 end