active-fedora 5.3.1 → 5.4.0

data/History.txt

@@ -1,3 +1,9 @@
+5.4.0
+HYDRA-850 Added finder methods like Base.where().limit().order().first
+Added Base.delete_all and Base.destroy_all
+Fixed RDF proxy delegates that weren't delegating 'is_a?'
+Better looking output for the Base#inspect method
+
 5.3.1
 Fixed delegating rdf terms as_json
 

data/LICENSE

@@ -1,20 +1,14 @@
-Copyright (c) 2009 Matt Zumwalt
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+##########################################################################
+# Copyright 2011 Stanford University Libraries (SULAIR) and MediaShelf, LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

data/lib/active_fedora.rb

@@ -50,8 +50,10 @@ module ActiveFedora #:nodoc:
     autoload :Property
     autoload :Persistence
     autoload :QualifiedDublinCoreDatastream
+    autoload :Querying
     autoload :RDFDatastream
     autoload :RdfxmlRDFDatastream
+    autoload :Relation
     autoload :RelsExtDatastream
     autoload :ServiceDefinitions
     autoload :SemanticNode

data/lib/active_fedora/base.rb

@@ -29,6 +29,7 @@ module ActiveFedora
     self.fedora_connection = {}
     self.profile_solr_name = ActiveFedora::SolrService.solr_name("object_profile", :string, :displayable)
 
+
     def method_missing(name, *args)
       dsid = corresponding_datastream_name(name)
       if dsid
@@ -285,9 +286,12 @@ module ActiveFedora
     end
 
 
-
-    def inspect
-      "#<#{self.class}:#{self.hash} @pid=\"#{pid}\" >"
+    def pretty_pid
+      if self.pid == UnsavedDigitalObject::PLACEHOLDER
+        nil
+      else
+        self.pid
+      end
     end
 
     # Return a Hash representation of this object where keys in the hash are appropriate Solr field names.
@@ -430,7 +434,6 @@ module ActiveFedora
         return arr
       end
     end
-    
   end
 
   Base.class_eval do
@@ -448,6 +451,7 @@ module ActiveFedora
     include Associations
     include NestedAttributes
     include Reflection
+    extend Querying
   end
 
 end

data/lib/active_fedora/datastream.rb

@@ -13,7 +13,7 @@ module ActiveFedora
     end
 
     def inspect
-      "#<#{self.class}:#{self.hash} @pid=\"#{digital_object ? pid : nil}\" @dsid=\"#{dsid}\" @controlGroup=\"#{controlGroup}\" changed=\"#{changed?}\" @mimeType=\"#{mimeType}\" >"
+      "#<#{self.class} @pid=\"#{digital_object ? pid : nil}\" @dsid=\"#{dsid}\" @controlGroup=\"#{controlGroup}\" changed=\"#{changed?}\" @mimeType=\"#{mimeType}\" >"
     end
 
     #compatibility method for rails' url generators. This method will 

data/lib/active_fedora/datastreams.rb

@@ -206,9 +206,10 @@ module ActiveFedora
 
     module ClassMethods
       #This method is used to specify the details of a datastream. 
-      #args must include :name. Note that this method doesn't actually
-      #execute the block, but stores it at the class level, to be executed
-      #by any future instantiations.
+      # You can pass the name as the first argument and a hash of options as the second argument
+      # or you can pass the :name as a value in the args hash. Either way, name is required.
+      # Note that this method doesn't actually execute the block, but stores it , to be executed
+      # by any the implementation of the datastream(specified as :type)
       #
       # @param [Hash] args 
       # @option args [Class] :type The class that will represent this datastream, should extend ``Datastream''
@@ -220,7 +221,17 @@ module ActiveFedora
       # @option args [Boolean] :autocreate Always create this datastream on new objects
       # @option args [Boolean] :versionable Should versioned datastreams be stored
       # @yield block executed by some kinds of datastreams
-      def has_metadata(args, &block)
+      def has_metadata(*args, &block)
+
+        if args.first.is_a? String 
+          name = args.first
+          args = args[1] || {}
+          args[:name] = name
+        else
+          args = args.first
+        end
+        
+        
         spec = {:autocreate => args.fetch(:autocreate, false), :type => args[:type], :label =>  args.fetch(:label,""), :control_group => args[:control_group], :disseminator => args.fetch(:disseminator,""), :url => args.fetch(:url,""),:block => block}
         spec[:versionable] = args[:versionable] if args.has_key? :versionable
         ds_specs[args[:name]]= spec
@@ -235,7 +246,14 @@ module ActiveFedora
       # @option args :control_group ("M") The type of controlGroup to store the datastream as. Defaults to M
       # @option args [Boolean] :autocreate Always create this datastream on new objects
       # @option args [Boolean] :versionable Should versioned datastreams be stored
-      def has_file_datastream(args = {})
+      def has_file_datastream(*args)
+        if args.first.is_a? String 
+          name = args.first
+          args = args[1] || {}
+          args[:name] = name
+        else
+          args = args.first || {}
+        end
         spec = {:autocreate => args.fetch(:autocreate, false), :type => args.fetch(:type,ActiveFedora::Datastream),
                 :label =>  args.fetch(:label,"File Datastream"), :control_group => args.fetch(:control_group,"M")}
         spec[:versionable] = args[:versionable] if args.has_key? :versionable

data/lib/active_fedora/delegating.rb

@@ -2,6 +2,17 @@ module ActiveFedora
   module Delegating
     extend ActiveSupport::Concern
 
+    included do
+      class_attribute  :delegate_registry
+      self.delegate_registry = []
+    end
+
+    # Calling inspect may trigger a bunch of loads, but it's mainly for debugging, so no worries.
+    def inspect
+      values = delegate_registry.map {|r| "#{r}:#{send(r).inspect}"}
+      "#<#{self.class} pid:\"#{pretty_pid}\", #{values.join(', ')}>"
+    end
+
     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
@@ -56,6 +67,7 @@ module ActiveFedora
 
       private
       def create_delegate_accessor(field, args)
+        self.delegate_registry += [field]
         define_method field do
           ds = self.send(args[:to])
           val = if ds.kind_of?(ActiveFedora::RDFDatastream)

data/lib/active_fedora/model.rb

@@ -45,25 +45,6 @@ module ActiveFedora
       result
     end
 
-
-    #
-    # =Class Methods
-    # These methods are mixed into the inheriting class.
-    #
-    # Accessor and mutator methods are dynamically generated based 
-    # on the contents of the @@field_spec hash, which stores the 
-    # field specifications recorded during invocation of has_metadata.
-    #
-    # Each metadata field will generate 3 methods:
-    #
-    #   fieldname_values
-    #     *returns the current values array for this field
-    #   fieldname_values=(val) 
-    #     *store val as the values array. val 
-    #     may be a single string, or an array of strings 
-    #     (single items become single element arrays).
-    #   fieldname_append(val)
-    #     *appends val to the values array.
     module ClassMethods
       # Returns a suitable uri object for :has_model
       # Should reverse Model#from_class_uri
@@ -81,164 +62,6 @@ module ActiveFedora
         "info:fedora/#{namespace}:#{ContentModel.sanitized_class_name(self)}#{pid_suffix}" 
       end
       
-      # Returns an Array of objects of the Class that +find+ is being 
-      # called on
-      #
-      # @param[String,Symbol,Hash] args either a pid or :all or a hash of conditions
-      # @param [Hash] opts the options to create a message with.
-      # @option opts [Integer] :rows when :all is passed, the maximum number of rows to load from solr
-      # @option opts [Boolean] :cast when true, examine the model and cast it to the first known cModel
-      def find(args, opts={}, &block)
-        return find_one(args, opts[:cast]) if args.class == String
-        return to_enum(:find, args, opts).to_a unless block_given?
-
-        args = {} if args == :all
-        find_each(args, opts) do |obj|
-          yield obj
-        end
-      end
-
-      def all(opts = {}, &block)
-        find(:all, opts, &block)
-      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.include?(:sort)
-          opts[:sort]=[ActiveFedora::SolrService.solr_name(:system_create,:date)+' asc'] 
-        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
-
-      # 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={})
-        find_in_batches(conditions, opts.merge({:fl=>SOLR_DOCUMENT_ID})) do |group|
-          group.each do |hit|
-            yield(find_one(hit[SOLR_DOCUMENT_ID], opts[:cast]))
-          end
-        end
-      end
-
-
-      # Returns true if the pid exists in the repository 
-      # @param[String] pid 
-      # @return[boolean] 
-      def exists?(pid)
-        inner = DigitalObject.find_or_initialize(self, pid)
-        !inner.new?
-      end
-
-      # Get a count of the number of objects from solr
-      # Takes :conditions as an argument
-      def count(args = {})
-        q = search_model_clause ? [search_model_clause] : []
-        q << "#{args[:conditions]}"  if args[:conditions]
-        SolrService.query(q.join(' AND '), :raw=>true, :rows=>0)['response']['numFound']
-      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]=[ActiveFedora::SolrService.solr_name(:system_create,:date)+' asc'] 
-        end
-        SolrService.query(create_query(conditions), opts) 
-      end
-
-      def quote_for_solr(value)
-        '"' + value.gsub(/(:)/, '\\:').gsub(/(\/)/, '\\/').gsub(/"/, '\\"') + '"'
-      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|
-          unless value.nil?
-            if value.is_a? Array
-              value.each do |val|
-                clauses << "#{key}:#{quote_for_solr(val)}"  
-              end
-            else
-              key = SOLR_DOCUMENT_ID if (key === :id || key === :pid)
-              escaped_value = quote_for_solr(value)
-              clauses << (key.to_s.eql?(SOLR_DOCUMENT_ID) ? "#{key}:#{escaped_value}" : "#{key}:#{escaped_value}")
-            end
-          end
-        end
-        return "*:*" if clauses.empty?
-        clauses.compact.join(" AND ")
-      end
-
-      def create_query_from_string(conditions)
-        model_clause = search_model_clause
-        model_clause ? "#{model_clause} AND (#{conditions})" : conditions
-      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
-
-      # 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=false)
-        inner = DigitalObject.find(self, pid)
-        af_base = self.allocate.init_with(inner)
-        cast ? af_base.adapt_to_cmodel : af_base
-      end
     end
 
     private 

data/lib/active_fedora/querying.rb

@@ -0,0 +1,146 @@
+module ActiveFedora
+  module Querying
+    delegate :find, :first, :where, :limit, :order, :all, :delete_all, :destroy_all, :to=>:relation
+    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]=[ActiveFedora::SolrService.solr_name(:system_create,:date)+' asc'] 
+      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
+
+    # 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={})
+      find_in_batches(conditions, opts.merge({:fl=>SOLR_DOCUMENT_ID})) do |group|
+        group.each do |hit|
+          yield(find_one(hit[SOLR_DOCUMENT_ID], opts[:cast]))
+        end
+      end
+    end
+
+
+    # Returns true if the pid exists in the repository 
+    # @param[String] pid 
+    # @return[boolean] 
+    def exists?(pid)
+      inner = DigitalObject.find_or_initialize(self, pid)
+      !inner.new?
+    end
+
+    # Get a count of the number of objects from solr
+    # Takes :conditions as an argument
+    def count(args = {})
+      q = search_model_clause ? [search_model_clause] : []
+      q << "#{args[:conditions]}"  if args[:conditions]
+      SolrService.query(q.join(' AND '), :raw=>true, :rows=>0)['response']['numFound']
+    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]=[ActiveFedora::SolrService.solr_name(:system_create,:date)+' asc'] 
+      end
+      SolrService.query(create_query(conditions), opts) 
+    end
+
+    def quote_for_solr(value)
+      '"' + value.gsub(/(:)/, '\\:').gsub(/(\/)/, '\\/').gsub(/"/, '\\"') + '"'
+    end
+
+    # 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=false)
+      inner = DigitalObject.find(self, pid)
+      af_base = self.allocate.init_with(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|
+        unless value.nil?
+          if value.is_a? Array
+            value.each do |val|
+              clauses << "#{key}:#{quote_for_solr(val)}"  
+            end
+          else
+            key = SOLR_DOCUMENT_ID if (key === :id || key === :pid)
+            escaped_value = quote_for_solr(value)
+            clauses << (key.to_s.eql?(SOLR_DOCUMENT_ID) ? "#{key}:#{escaped_value}" : "#{key}:#{escaped_value}")
+          end
+        end
+      end
+      return "*:*" if clauses.empty?
+      clauses.compact.join(" AND ")
+    end
+
+    def create_query_from_string(conditions)
+      model_clause = search_model_clause
+      model_clause ? "#{model_clause} AND (#{conditions})" : conditions
+    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