active-fedora 6.8.0 → 7.0.0.pre1

data/lib/active_fedora/fixture_loader.rb

@@ -35,7 +35,7 @@ module ActiveFedora
     end
 
     def self.index(pid)
-        ActiveFedora::Base.find(pid, cast: true).update_index
+      ActiveFedora::Base.find(pid).update_index
     end
 
     def self.import_to_fedora(filename, pid='0')

data/lib/active_fedora/indexing.rb

@@ -2,6 +2,11 @@ module ActiveFedora
   module Indexing
     extend ActiveSupport::Concern
 
+    included do
+      class_attribute :profile_solr_name
+      self.profile_solr_name = ActiveFedora::SolrService.solr_name("object_profile", :displayable)
+    end
+
     # Return a Hash representation of this object where keys in the hash are appropriate Solr field names.
     # @param [Hash] solr_doc (optional) Hash to insert the fields into
     # @param [Hash] opts (optional)
@@ -93,7 +98,7 @@ module ActiveFedora
         connections.each do |conn|
           conn.search(query) do |object|
             next if object.pid.start_with?('fedora-system:')
-            ActiveFedora::Base.find(object.pid, :cast=>true).update_index
+            ActiveFedora::Base.find(object.pid).update_index
           end
         end
       end

data/lib/active_fedora/model.rb

@@ -34,23 +34,6 @@ module ActiveFedora
       result
     end
 
-    # Returns a suitable uri object for :has_model
-    # Should reverse Model#from_class_uri
-    def to_class_uri(attrs = {})
-      if self.respond_to? :pid_suffix
-        pid_suffix = self.pid_suffix
-      else
-        pid_suffix = attrs.fetch(:pid_suffix, ContentModel::CMODEL_PID_SUFFIX)
-      end
-      if self.respond_to? :pid_namespace
-        namespace = self.pid_namespace
-      else
-        namespace = attrs.fetch(:namespace, ContentModel::CMODEL_NAMESPACE)
-      end
-      "info:fedora/#{namespace}:#{ContentModel.sanitized_class_name(self)}#{pid_suffix}" 
-    end
-      
-
     private 
     
     def self.class_exists?(class_name)

data/lib/active_fedora/nested_attributes.rb

@@ -118,7 +118,7 @@ module ActiveFedora
       if attributes_collection.is_a? Hash
         keys = attributes_collection.keys
         attributes_collection = if keys.include?('id') || keys.include?(:id)
-          Array.wrap(attributes_collection)
+          Array(attributes_collection)
         else
           attributes_collection.sort_by { |i, _| i.to_i }.map { |_, attributes| attributes }
         end
@@ -130,7 +130,7 @@ module ActiveFedora
         association.to_a
       else
         attribute_ids = attributes_collection.map {|a| a['id'] || a[:id] }.compact
-        attribute_ids.present? ? association.select{ |x| attribute_ids.include?(x.pid)} : []
+        attribute_ids.present? ? association.to_a.select{ |x| attribute_ids.include?(x.pid)} : []
       end
 
       attributes_collection.each do |attributes|

data/lib/active_fedora/null_relation.rb

@@ -0,0 +1,7 @@
+module ActiveFedora
+  module NullRelation # :nodoc:
+    def exists?(_id = false)
+      false
+    end
+  end
+end

data/lib/active_fedora/om_datastream.rb

@@ -24,7 +24,7 @@ module ActiveFedora
 
     # Create an instance of this class based on xml content
     # @param [String, File, Nokogiri::XML::Node] xml the xml content to build from
-    # @param [ActiveFedora::NokogiriDatastream] tmpl the Datastream object that you are building @default a new instance of this class
+    # @param [ActiveFedora::OmDatastream] tmpl the Datastream object that you are building @default a new instance of this class
     # Careful! If you call this from a constructor, be sure to provide something 'ie. self' as the @tmpl. Otherwise, you will get an infinite loop!
     def self.from_xml(xml, tmpl=nil)
       tmpl = self.new if tmpl.nil?  ## This path is used only for unit testing (e.g. MarpaDCDatastream.from_xml(fixture("data.xml")) )
@@ -70,7 +70,7 @@ module ActiveFedora
       when String 
         self.content=new_xml
       else
-        raise TypeError, "You passed a #{new_xml.class} into the ng_xml of the #{self.dsid} datastream. NokogiriDatastream.ng_xml= only accepts Nokogiri::XML::Document, Nokogiri::XML::Element, Nokogiri::XML::Node, or raw XML (String) as inputs."
+        raise TypeError, "You passed a #{new_xml.class} into the ng_xml of the #{self.dsid} datastream. OmDatastream.ng_xml= only accepts Nokogiri::XML::Document, Nokogiri::XML::Element, Nokogiri::XML::Node, or raw XML (String) as inputs."
       end
     end
     
@@ -126,7 +126,6 @@ module ActiveFedora
 
     def content_changed?
       return false if !xml_loaded
-      return true if changed_attributes.any?
       super
     end
 
@@ -357,7 +356,7 @@ module ActiveFedora
     #   </mods>
     def update_indexed_attributes(params={}, opts={})    
       if self.class.terminology.nil?
-        raise "No terminology is set for this NokogiriDatastream class.  Cannot perform update_indexed_attributes"
+        raise "No terminology is set for this OmDatastream class.  Cannot perform update_indexed_attributes"
       end
       # remove any fields from params that this datastream doesn't recognize    
       # make sure to make a copy of params so not to modify hash that might be passed to other methods

data/lib/active_fedora/persistence.rb

@@ -2,19 +2,41 @@ module ActiveFedora
   # = Active Fedora Persistence
   module Persistence
     extend ActiveSupport::Concern
+    extend Deprecation
+    self.deprecation_horizon = 'active-fedora version 8.0.0'
+    
+
+    def new?
+      new_record?
+    end
+    deprecation_deprecate :new?
+
+    # Has this object been saved?
+    def new_object?
+      new_record?
+    end
+    deprecation_deprecate :new_object?
+    
+
+    ## Required by associations
+    def new_record?
+      inner_object.new?
+    end
+
+    def persisted?
+      !(new_record? || destroyed?)
+    end
+
+    # Returns true if this object has been destroyed, otherwise returns false.
+    def destroyed?
+      @destroyed
+    end
 
     #Saves a Base object, and any dirty datastreams, then updates 
     #the Solr index for this object.
     def save(*)
       # If it's a new object, set the conformsTo relationship for Fedora CMA
-      if new_record?
-        result = create
-        update_index if create_needs_index?
-      else
-        result = update_record
-        update_index if update_needs_index?
-      end
-      return result
+      new_record? ? create : update_record
     end
 
     def save!(*)
@@ -41,29 +63,16 @@ module ActiveFedora
 #      inner_object.load_attributes_from_fedora
     end
 
-    def dependent_objects
-      # Loop over all the inbound associations (has_many reflections)
-      results = {}
-      reflections.each_pair do |name, reflection|
-        if reflection.macro == :has_many
-          results[reflection.options[:property]] = send(name)
-        end
-      end
-      results.merge (inbound_relationships(:object) )
-    end
-
     #Deletes a Base object, also deletes the info indexed in Solr, and 
     #the underlying inner_object.  If this object is held in any relationships (ie inbound relationships
     #outside of this object it will remove it from those items rels-ext as well
     def delete
-      dependent_objects.each_pair do |predicate, objects|
-        objects.each do |obj|
-          if obj.respond_to?(:remove_relationship)
-            obj.remove_relationship(predicate,self)
-            obj.save
-          end 
+      reflections.each_pair do |name, reflection|
+        if reflection.macro == :has_many
+          association(name).delete_all
         end
       end
+
       
       #Fedora::Repository.instance.delete(@inner_object)
       pid = self.pid ## cache so it's still available after delete
@@ -77,6 +86,8 @@ module ActiveFedora
         solr.delete_by_id(pid) 
         solr.commit
       end
+      @destroyed = true
+      freeze
     end
 
     def destroy
@@ -138,11 +149,11 @@ module ActiveFedora
     def create
       assign_pid
       assert_content_model
-      persist
+      persist(create_needs_index?)
     end
 
     def update_record
-      persist
+      persist(update_needs_index?)
     end
 
     # replace the unsaved digital object with a saved digital object
@@ -150,15 +161,16 @@ module ActiveFedora
       @inner_object = @inner_object.save 
     end
     
-    def persist
+    def persist(should_update_index)
+      serialize_datastreams
       result = @inner_object.save
-
       ### Rubydora re-inits the datastreams after a save, so ensure our copy stays in synch
       @inner_object.datastreams.each do |dsid, ds|
         datastreams[dsid] = ds
         ds.model = self if ds.kind_of? RelsExtDatastream
       end 
       refresh
+      update_index if should_update_index
       return !!result
     end
   end

data/lib/active_fedora/querying.rb

@@ -1,180 +1,19 @@
 module ActiveFedora
   module Querying
-    delegate :find, :first, :where, :limit, :order, :all, :delete_all, :destroy_all, :count, :last, :to=>:relation
+    delegate :find, :first, :exists?, :where, :limit, :order, :delete_all, 
+      :destroy_all, :count, :last, :find_with_conditions, :find_in_batches, :find_each, :to=>:all
 
     def self.extended(base)
       base.class_attribute  :solr_query_handler
       base.solr_query_handler = 'standard'
     end
-    
-
-    def relation
-      Relation.new(self)
-    end
-
-    # Yields each batch of solr records that was found by the find +options+ as
-    # an array. The size of each batch is set by the <tt>:batch_size</tt>
-    # option; the default is 1000.
-    #
-    # Returns a solr result matching the supplied conditions
-    # @param[Hash] conditions solr conditions to match
-    # @param[Hash] options 
-    # @option opts [Array] :sort a list of fields to sort by 
-    # @option opts [Array] :rows number of rows to return
-    #
-    # @example
-    #  Person.find_in_batches('age_t'=>'21', {:batch_size=>50}) do |group|
-    #  group.each { |person| puts person['name_t'] }
-    #  end
-    
-    def find_in_batches conditions, opts={}
-      opts[:q] = create_query(conditions)
-      opts[:qt] = solr_query_handler
-      #set default sort to created date ascending
-      unless opts[:sort].present?
-        opts[:sort]= default_sort_params
-      end
-
-      batch_size = opts.delete(:batch_size) || 1000
-
-      counter = 0
-      begin
-        counter += 1
-        response = ActiveFedora::SolrService.instance.conn.paginate counter, batch_size, "select", :params => opts
-        docs = response["response"]["docs"]
-        yield docs
-      end while docs.has_next? 
-    end
-
-    def calculate(calculation, conditions, opts={})
-      SolrService.query(create_query(conditions), :raw=>true, :rows=>0)['response']['numFound']
-    end
 
     def default_sort_params
       [ActiveFedora::SolrService.solr_name(:system_create, :stored_sortable, type: :date)+' asc'] 
     end
 
-    # Yields the found ActiveFedora::Base object to the passed block
-    #
-    # @param [Hash] conditions the conditions for the solr search to match
-    # @param [Hash] opts 
-    # @option opts [Boolean] :cast when true, examine the model and cast it to the first known cModel
-    def find_each( conditions={}, opts={})
-      cast = opts.delete(:cast)
-      find_in_batches(conditions, opts.merge({:fl=>SOLR_DOCUMENT_ID})) do |group|
-        group.each do |hit|
-          begin 
-            yield(find_one(hit[SOLR_DOCUMENT_ID], cast))
-          rescue ActiveFedora::ObjectNotFoundError
-            logger.error "When trying to find_each #{hit[SOLR_DOCUMENT_ID]}, encountered an ObjectNotFoundError. Solr may be out of sync with Fedora"
-          end
-        end
-      end
-    end
-
-
-    # Returns true if the pid exists in the repository
-    # @param[String] pid
-    # @return[boolean]
-    def exists?(pid)
-      return false if pid.nil? || pid.empty?
-      !!DigitalObject.find(self, pid)
-    rescue ActiveFedora::ObjectNotFoundError
-      false
-    end
-
-    # Returns a solr result matching the supplied conditions
-    # @param[Hash,String] conditions can either be specified as a string, or 
-    # hash representing the query part of an solr statement. If a hash is 
-    # provided, this method will generate conditions based simple equality
-    # combined using the boolean AND operator.
-    # @param[Hash] options 
-    # @option opts [Array] :sort a list of fields to sort by 
-    # @option opts [Array] :rows number of rows to return
-    def find_with_conditions(conditions, opts={})
-      #set default sort to created date ascending
-      unless opts.include?(:sort)
-        opts[:sort]=default_sort_params
-      end
-      SolrService.query(create_query(conditions), opts) 
-    end
-
     def quote_for_solr(value)
       '"' + value.gsub(/(:)/, '\\:').gsub(/(\/)/, '\\/').gsub(/"/, '\\"') + '"'
     end
-
-
-    extend Deprecation
-    self.deprecation_horizon = 'active-fedora 7.0.0'
-
-    # Retrieve the Fedora object with the given pid, explore the returned object, determine its model 
-    # using #{ActiveFedora::ContentModel.known_models_for} and cast to that class.
-    # Raises a ObjectNotFoundError if the object is not found.
-    # @param [String] pid of the object to load
-    # @param [Boolean] cast when true, cast the found object to the class of the first known model defined in it's RELS-EXT
-    #
-    # @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_one("hydra:dataset1") 
-    def find_one(pid, cast=nil)
-      if self == ActiveFedora::Base && cast.nil?
-        cast = false
-        Deprecation.warn(Querying, "find_one's cast parameter will default to true in ActiveFedora 7.0.0. If you want to maintain your existing behavior set `false' as the second parameter.", caller)
-      end
-      inner = DigitalObject.find(self, pid)
-      af_base = self.allocate.init_with_object(inner)
-      cast ? af_base.adapt_to_cmodel : af_base
-    end
-    
-    private 
-
-    # Returns a solr query for the supplied conditions
-    # @param[Hash] conditions solr conditions to match
-    def create_query(conditions)
-      conditions.kind_of?(Hash) ? create_query_from_hash(conditions) : create_query_from_string(conditions)
-    end
-
-    def create_query_from_hash(conditions)
-      clauses = search_model_clause ?  [search_model_clause] : []
-      conditions.each_pair do |key,value|
-        clauses << condition_to_clauses(key, value)
-      end
-      return "*:*" if clauses.empty?
-      clauses.compact.join(" AND ")
-    end
-
-    def condition_to_clauses(key, value)
-      unless value.nil?
-        # if the key is a property name, turn it into a solr field
-        if self.defined_attributes.key?(key)
-          # TODO Check to see if `key' is a possible solr field for this class, if it isn't try :searchable instead
-          key = ActiveFedora::SolrService.solr_name(key, :stored_searchable, type: :string)
-        end
-        if value.is_a? Array
-          value.map { |val| "#{key}:#{quote_for_solr(val)}" }
-        elsif value.is_a? String and value.empty?
-          "-#{key}:['' TO *]"
-        else
-          key = SOLR_DOCUMENT_ID if (key === :id || key === :pid)
-          escaped_value = quote_for_solr(value)
-          key.to_s.eql?(SOLR_DOCUMENT_ID) ? "#{key}:#{escaped_value}" : "#{key}:#{escaped_value}"
-        end
-      end
-    end
-
-    def create_query_from_string(conditions)
-      model_clause = search_model_clause
-      if model_clause 
-        conditions ? "#{model_clause} AND (#{conditions})" : model_clause
-      else
-        conditions
-      end
-    end
-
-    # Return the solr clause that queries for this type of class
-    def search_model_clause
-      unless self == ActiveFedora::Base
-        return ActiveFedora::SolrService.construct_query_for_rel(:has_model => self.to_class_uri)
-      end
-    end
   end
 end

data/lib/active_fedora/rdf.rb

@@ -3,5 +3,6 @@ module ActiveFedora
     extend ActiveSupport::Autoload
     autoload :NestedAttributes
     autoload :NodeConfig
+    autoload :Indexing
   end
 end

data/lib/active_fedora/rdf/indexing.rb

@@ -0,0 +1,67 @@
+module ActiveFedora
+  module Rdf
+    module Indexing
+      extend ActiveSupport::Concern
+
+      def prefix(name)
+        self.class.prefix(dsid, name)
+      end
+
+      def to_solr(solr_doc = Hash.new) # :nodoc:
+        fields.each do |field_key, field_info|
+          values = get_values(rdf_subject, field_key)
+          Array(values).each do |val|    
+            val = val.to_s if val.kind_of? RDF::URI
+            Solrizer.insert_field(solr_doc, prefix(field_key), val, *field_info[:behaviors])
+          end
+        end
+        solr_doc
+      end
+
+
+      module ClassMethods
+        def prefix(dsid, name)
+          "#{dsid.underscore}__#{name}".to_sym
+        end
+
+        # Gives the primary solr name for a column. If there is more than one indexer on the field definition, it gives the first 
+        def primary_solr_name(dsid, field)
+          config = config_for_term_or_uri(field)
+          if behaviors = config.behaviors
+            ActiveFedora::SolrService.solr_name(prefix(dsid, field), behaviors.first, type: config.type)
+          end
+        end
+
+        # Gives the datatype for a column.
+        def type(field)
+          config_for_term_or_uri(field).type
+        end
+      end
+
+      private
+        # returns a Hash, e.g.: {field => {:values => [], :type => :something, :behaviors => []}, ...}
+        def fields
+          field_map = {}.with_indifferent_access
+
+          rdf_subject = self.rdf_subject
+          query = RDF::Query.new do
+            pattern [rdf_subject, :predicate, :value]
+          end
+
+          query.execute(graph).each do |solution|
+            predicate = solution.predicate
+            value = solution.value
+            
+            name, config = self.class.config_for_predicate(predicate)
+            next unless config
+            type = config.type
+            behaviors = config.behaviors
+            next unless type and behaviors 
+            field_map[name] ||= {:values => [], :type => type, :behaviors => behaviors}
+            field_map[name][:values] << value.to_s
+          end
+          field_map
+        end
+    end
+  end
+end