active-fedora 5.3.1 → 5.4.0

data/lib/active_fedora/rdf_datastream.rb

@@ -111,7 +111,7 @@ module ActiveFedora
     class TermProxy
 
       attr_reader :graph, :subject, :predicate
-      delegate :class, :to_s, :==, :kind_of?, :each, :map, :empty?, :as_json, :to => :values
+      delegate :class, :to_s, :==, :kind_of?, :each, :map, :empty?, :as_json, :is_a?, :to => :values
 
       def initialize(graph, subject, predicate)
         @graph = graph

data/lib/active_fedora/relation.rb

@@ -0,0 +1,229 @@
+module ActiveFedora
+  class Relation
+
+    attr_reader :loaded
+    alias :loaded? :loaded
+
+    attr_accessor :limit_value, :where_values, :order_values
+    
+    def initialize(klass)
+      @klass = klass
+      @loaded = false
+      self.where_values = []
+      self.order_values = []
+    end
+
+    def reset
+      @first = @loaded = nil
+      @records = []
+      self
+    end
+
+
+    # Returns the first records that was found.
+    #
+    # @example
+    #  Person.where(name_t: 'Jones').first
+    #    => #<Person @id="foo:123" @name='Jones' ... >
+    def first
+      if loaded?
+        @records.first
+      else
+        @first ||= limit(1).to_a[0]
+      end
+    end
+
+    # Limits the number of returned records to the value specified
+    #
+    # @option [Integer] value the number of records to return
+    #
+    # @example
+    #  Person.where(name_t: 'Jones').limit(10)
+    #    => [#<Person @id="foo:123" @name='Jones'>, #<Person @id="foo:125" @name='Jones'>, ...]
+    def limit(value)
+      relation = clone
+      relation.limit_value = value
+      relation
+    end
+
+    # Limits the returned records to those that match the provided search conditions
+    #
+    # @option [Hash] opts a hash of solr conditions
+    #
+    # @example
+    #  Person.where(name_t: 'Mario', occupation_s: 'Plumber')
+    #    => [#<Person @id="foo:123" @name='Mario'>, #<Person @id="foo:125" @name='Mario'>, ...]
+    def where(opts)
+      return self if opts.blank?
+      relation = clone
+      relation.where_values = opts
+      relation
+    end
+
+    # Order the returned records by the field and direction provided
+    #
+    # @option [Array<String>] args a list of fields and directions to sort by 
+    #
+    # @example
+    #  Person.where(occupation_s: 'Plumber').order('name_t desc', 'color_t asc')
+    #    => [#<Person @id="foo:123" @name='Luigi'>, #<Person @id="foo:125" @name='Mario'>, ...]
+    def order(*args)
+      return self if args.blank?
+
+      relation = clone
+      relation.order_values += args.flatten
+      relation
+    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)
+      return to_a.find { |*block_args| yield(*block_args) } if block_given?
+      options = args.extract_options!
+
+      # TODO is there any reason not to cast?
+      cast = options.delete(:cast)
+      if options[:sort]
+        # Deprecate sort sometime?
+        sort = options.delete(:sort) 
+        options[:order] ||= sort if sort.present?
+      end
+
+
+      if options.present?
+        options = {conditions: options}
+        apply_finder_options(options).all
+      else
+        case args.first
+        when :first, :last, :all
+          send(args.first)
+        else
+          find_with_ids(args, cast)
+        end
+      end
+    end
+
+    def find_with_ids(ids, cast)
+      expects_array = ids.first.kind_of?(Array)
+      return ids.first if expects_array && ids.first.empty?
+
+      ids = ids.flatten.compact.uniq
+
+      case ids.size
+      when 0
+        raise ArgumentError, "Couldn't find #{@klass.name} without an ID"
+      when 1
+        result = @klass.find_one(ids.first, cast)
+        expects_array ? [ result ] : result
+      else
+        find_some(ids, cast)
+      end
+    end
+
+    def find_some(ids, cast)
+      ids.map{|id| @klass.find_one(id, cast)}
+    end
+
+    # A convenience wrapper for <tt>find(:all, *args)</tt>. You can pass in all the
+    # same arguments to this method as you can to <tt>find(:all)</tt>.
+    def all(*args)
+      args.any? ? apply_finder_options(args.first).to_a : to_a
+    end
+
+
+
+    def to_a
+      return @records if loaded?
+      args = {} #:cast=>true}
+      args[:rows] = @limit_value if @limit_value
+      args[:sort] = @order_values if @order_values
+      
+      query = @where_values.present? ? @where_values : {}
+      @records = @klass.to_enum(:find_each, query, args).to_a
+
+      @records
+    end
+
+    def ==(other)
+      case other
+      when Relation
+        other.where_values == where_values
+      when Array
+        to_a == other
+      end
+    end
+
+    def inspect
+      to_a.inspect
+    end
+
+    # Destroys the records matching +conditions+ by instantiating each
+    # record and calling its +destroy+ method. Each object's callbacks are
+    # executed (including <tt>:dependent</tt> association options and
+    # +before_destroy+/+after_destroy+ Observer methods). Returns the
+    # collection of objects that were destroyed; each will be frozen, to
+    # reflect that no changes should be made (since they can't be
+    # persisted).
+    #
+    # Note: Instantiation, callback execution, and deletion of each
+    # record can be time consuming when you're removing many records at
+    # once. It generates at least one fedora +DELETE+ query per record (or
+    # possibly more, to enforce your callbacks). If you want to delete many
+    # rows quickly, without concern for their associations or callbacks, use
+    # +delete_all+ instead.
+    #
+    # ==== Parameters
+    #
+    # * +conditions+ - A string, array, or hash that specifies which records
+    #   to destroy. If omitted, all records are destroyed. See the
+    #   Conditions section in the ActiveFedora::Relation#where for
+    #   more information.
+    #
+    # ==== Examples
+    #
+    #   Person.destroy_all(:status_s => "inactive")
+    #   Person.where(:age_i => 18).destroy_all
+    def destroy_all(conditions = nil)
+      if conditions
+        where(conditions).destroy_all
+      else
+        to_a.each {|object| object.destroy }.tap { reset }
+      end
+    end
+
+    def delete_all(conditions = nil)
+      if conditions
+        where(conditions).delete_all
+      else
+        to_a.each {|object| object.delete }.tap { reset }
+      end
+    end
+
+
+    private
+
+    VALID_FIND_OPTIONS = [:order, :limit, :conditions, :cast]
+    
+    def apply_finder_options(options)
+      relation = clone
+      return relation unless options
+
+      options.assert_valid_keys(VALID_FIND_OPTIONS)
+      finders = options.dup
+      finders.delete_if { |key, value| value.nil? && key != :limit }
+
+      ([:order,:limit] & finders.keys).each do |finder|
+        relation = relation.send(finder, finders[finder])
+      end
+
+      relation = relation.where(finders[:conditions]) if options.has_key?(:conditions)
+      relation
+    end
+    
+  end
+end

data/lib/active_fedora/unsaved_digital_object.rb

@@ -3,6 +3,8 @@ module ActiveFedora
   class UnsavedDigitalObject 
     include DigitalObject::DatastreamBootstrap
     attr_accessor :original_class, :ownerId, :datastreams, :label, :namespace
+
+    PLACEHOLDER = '__DO_NOT_USE__'
     
     def initialize(original_class, namespace, pid=nil)
       @pid = pid
@@ -12,7 +14,7 @@ module ActiveFedora
     end
 
     def pid
-      @pid || '__DO_NOT_USE__'
+      @pid || PLACEHOLDER
     end
 
 

data/lib/active_fedora/version.rb

@@ -1,3 +1,3 @@
 module ActiveFedora
-  VERSION = "5.3.1"
+  VERSION = "5.4.0"
 end

data/spec/integration/delete_all_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe ActiveFedora::Base do
+  
+  before(:all) do
+    module SpecModel
+      class Basic < ActiveFedora::Base
+        class_attribute :callback_counter
+        
+        before_destroy :inc_counter
+
+        def inc_counter
+          self.class.callback_counter += 1
+        end
+      end
+    end
+  end
+  
+  after(:all) do
+    Object.send(:remove_const, :SpecModel)
+  end
+
+  before do
+    SpecModel::Basic.create!
+    SpecModel::Basic.create!
+    SpecModel::Basic.callback_counter = 0
+    @count = SpecModel::Basic.count
+  end
+
+
+  describe ".destroy_all" do
+    it "should remove both and run callbacks" do 
+      SpecModel::Basic.destroy_all
+      SpecModel::Basic.count.should == @count - 2
+      SpecModel::Basic.callback_counter.should == 2
+    end
+
+  end
+
+  describe ".delete_all" do
+    it "should remove both and not run callbacks" do 
+      SpecModel::Basic.delete_all
+      SpecModel::Basic.count.should == @count - 2
+      SpecModel::Basic.callback_counter.should == 0
+    end
+  end
+end

data/spec/integration/ntriples_datastream_spec.rb

@@ -82,6 +82,41 @@ describe ActiveFedora::NtriplesRDFDatastream do
     @subject.save
   end
 
+  it "should load n-triples into the graph" do
+    ntrip = '<http://oregondigital.org/ns/62> <http://purl.org/dc/terms/type> "Image" .
+<http://oregondigital.org/ns/62> <http://purl.org/dc/terms/spatial> "Benton County (Ore.)" .
+'
+    @subject.rdf.content = ntrip
+    @subject.rdf.graph.dump(:ntriples).should == ntrip
+  end
+
+  describe "using rdf_subject" do
+    before do
+      # reopening existing class
+      class MyDatastream < ActiveFedora::NtriplesRDFDatastream
+        rdf_subject { |ds| RDF::URI.new("http://oregondigital.org/ns/#{ds.pid.split(':')[1]}") }
+        map_predicates do |map|
+          map.type(:in => RDF::DC)
+          map.spatial(:in => RDF::DC)
+        end
+      end
+    end
+    after do
+      @subject.destroy
+    end
+
+    it "should write rdf with proper subjects" do
+      @subject.rdf.type = "Frog"
+      @subject.inner_object.pid = 'foo:99'
+      @subject.save!
+      @subject.reload
+      @subject.rdf.graph.dump(:ntriples).should == "<http://oregondigital.org/ns/99> <http://purl.org/dc/terms/type> \"Frog\" .\n"
+      @subject.rdf.type == ['Frog']
+
+    end
+
+  end
+
 
   it "should delete values" do
     @subject.title = "Hamlet"
@@ -148,5 +183,8 @@ describe ActiveFedora::NtriplesRDFDatastream do
       @subject.title.delete("title1", "title2", "title3")
       @subject.title.empty?.should be_true
     end
+    it "should support the is_a? method" do
+      @subject.title.is_a?(Array).should == true
+    end
   end
 end

data/spec/integration/scoped_query_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe ActiveFedora::Model do
+  
+  before(:each) do 
+    module ModelIntegrationSpec
+      class Basic < ActiveFedora::Base
+        has_metadata :name => "properties", :type => ActiveFedora::SimpleDatastream do |m|
+          m.field "foo", :string
+          m.field "bar", :string
+          m.field "baz", :string
+        end
+
+        delegate_to :properties, [:foo, :bar, :baz]
+
+        def to_solr(doc = {})
+          doc = super
+          doc['foo_sort'] = doc['foo_t']
+          doc
+        end
+      
+      end
+    end
+
+  end
+  
+  after(:each) do
+    Object.send(:remove_const, :ModelIntegrationSpec)
+  end
+
+
+  describe "When there is one object in the store" do
+    before do
+      @test_instance = ModelIntegrationSpec::Basic.new
+      @test_instance.save
+    end
+
+    after do
+      @test_instance.delete
+    end
+
+    
+    describe ".all" do
+      it "should return an array of instances of the calling Class" do
+        result = ModelIntegrationSpec::Basic.all
+        result.should be_instance_of(Array)
+        # this test is meaningless if the array length is zero
+        result.length.should > 0
+        result.each do |obj|
+          obj.class.should == ModelIntegrationSpec::Basic
+        end
+      end
+    end
+
+    describe ".first" do
+      it "should return one instance of the calling class" do
+        ModelIntegrationSpec::Basic.first.should == @test_instance
+      end
+    end
+  end
+
+  describe "with multiple objects" do
+    before do
+      @test_instance1 = ModelIntegrationSpec::Basic.create!(:foo=>'Beta', :bar=>'Chips')
+      @test_instance2 = ModelIntegrationSpec::Basic.create!(:foo=>'Alpha', :bar=>'Peanuts')
+      @test_instance3 = ModelIntegrationSpec::Basic.create!(:foo=>'Sigma', :bar=>'Peanuts')
+    end
+    after do
+      @test_instance1.delete
+      @test_instance2.delete
+      @test_instance3.delete
+    end
+    it "should query" do
+      ModelIntegrationSpec::Basic.where(:foo_t => 'Beta').should == [@test_instance1]
+    end
+    it "should order" do
+      ModelIntegrationSpec::Basic.order('foo_sort asc').should == [@test_instance2, @test_instance1, @test_instance3]
+    end
+    it "should limit" do
+      ModelIntegrationSpec::Basic.limit(1).should == [@test_instance1]
+    end
+
+    it "should chain them" do
+      ModelIntegrationSpec::Basic.where(:bar_t => 'Peanuts').order('foo_sort asc').limit(1).should == [@test_instance2]
+    end
+  end
+end
+