active-fedora 4.0.0.rc9 → 4.0.0.rc10

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    active-fedora (4.0.0.rc9)
+    active-fedora (4.0.0.rc10)
       activeresource (>= 3.0.0)
       activesupport (>= 3.0.0)
       equivalent-xml

data/History.txt

@@ -1,4 +1,4 @@
-4.0.0.rc9
+4.0.0.rc10
 Removed deprecations
   * allowing :fedora level in fedora.yml
   * automatic includes of Relationships and FileMethods is removed
@@ -14,6 +14,10 @@ Find raises ObjectNotFoundError when the object isn't found
 Removed dependency on solrizer-fedora
 Avoid unnecessary reload of RELS-EXT when typecasting
 HYDRA-754 Delegate discovery of config parameters to a separate module to allow for non-file-based configuration
+HYDRA-753 has_metadata should accept :versionable as part of the spec.
+HYDRA-755 Instantiate un-spec'ed datastreams in SolrDigitalObject
+HYDRA-758 Added ActiveFedora::Base.exists?
+Fixes for Ruby 1.9 compatibility
 
 3.3.2
 HYDRA-745 No need to require :url be present on external datastreams

data/lib/active_fedora/base.rb

@@ -370,7 +370,7 @@ module ActiveFedora
         raise "Solr document record id and pid do not match" unless pid == solr_doc[SOLR_DOCUMENT_ID]
       end
      
-      obj = self.allocate.init_with(SolrDigitalObject.new(solr_doc))
+      obj = self.allocate.init_with(SolrDigitalObject.new(solr_doc, self))
       #set by default to load any dependent relationship objects from solr as well
       #need to call rels_ext once so it exists when iterating over datastreams
       obj.rels_ext

data/lib/active_fedora/datastreams.rb

@@ -78,7 +78,7 @@ module ActiveFedora
       ds = ds_spec[:type].new(inner_object, name)
       ds.dsLabel = ds_spec[:label] if ds_spec[:label].present?
       ds.controlGroup = ds_spec[:control_group]
-      ds.versionable = ds_spec[:versionable]
+      ds.versionable = ds_spec[:versionable] unless ds_spec[:versionable].nil?
       additional_attributes_for_external_and_redirect_control_groups(ds, ds_spec)
       ds
     end
@@ -252,7 +252,9 @@ module ActiveFedora
       # @option args [Boolean] :versionable (true) Should versioned datastreams be stored
       # @yield block executed by some kinds of datastreams
       def has_metadata(args, &block)
-        ds_specs[args[:name]]= {:type => args[:type], :label =>  args.fetch(:label,""), :control_group => args.fetch(:control_group,"X"), :disseminator => args.fetch(:disseminator,""), :url => args.fetch(:url,""),:block => block}
+        spec = {:type => args[:type], :label =>  args.fetch(:label,""), :control_group => args.fetch(:control_group,"X"), :disseminator => args.fetch(:disseminator,""), :url => args.fetch(:url,""),:block => block}
+        spec[:versionable] = args[:versionable] if args.has_key? :versionable
+        ds_specs[args[:name]]= spec
       end
 
       # Specify the attributes of a file bearing datastream 

data/lib/active_fedora/model.rb

@@ -114,6 +114,13 @@ module ActiveFedora
         end
       end
 
+      # Returns true if the pid exists in the repository 
+      # @param[String] pid 
+      # @return[boolean] 
+      def exists?(pid)
+        inner = DigitalObject.find(self, pid)
+        !inner.new?
+      end
 
       def find_model(pid)
         ActiveSupport::Deprecation.warn("find_model is deprecated.  Use find instead")

data/lib/active_fedora/rdf_datastream.rb

@@ -2,6 +2,24 @@ require 'rdf'
 
 module ActiveFedora
   class RDFDatastream < Datastream
+    # this enables a cleaner API for solr integration
+    class IndexObject
+      attr_accessor :data_type, :behaviors
+      def initialize
+        @behaviors = [:searchable]
+        @data_type = :string
+      end
+      def as(*args)
+        @behaviors = args
+      end
+      def type(sym)
+        @data_type = sym
+      end
+      def defaults
+        :noop
+      end
+    end
+
     module ModelMethods
       extend ActiveSupport::Concern
       module ClassMethods
@@ -24,57 +42,64 @@ module ActiveFedora
         def map_predicates(&block)
           yield self
         end
-        def method_missing(name, *args)
+        def method_missing(name, *args, &block)
           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)
-          data_type = args.fetch(:type, :string)
           raise "Vocabulary '#{vocab.inspect}' does not define property '#{predicate.inspect}'" unless vocab.respond_to? predicate
+          indexing = false
+          if block_given?
+            # needed for solrizer integration
+            indexing = true
+            iobj = IndexObject.new
+            yield iobj
+            data_type = iobj.data_type
+            behaviors = iobj.behaviors
+          end
+          # needed for AF::Predicates integration & drives all other
+          # functionality below
           vocab = vocab.to_s
-          # this is needed for AF::Predicates integration
-          # stuff data_type in there too for to_solr support
-          if config 
+          if config
             if config[:predicate_mapping].has_key? vocab
               config[:predicate_mapping][vocab][name] = predicate
-              config[:predicate_mapping][vocab]["#{name}type".to_sym] = data_type
             else
-              config[:predicate_mapping][vocab] = { name => predicate, "#{name}type".to_sym => data_type }
-           end
+              config[:predicate_mapping][vocab] = { name => predicate } 
+            end
+            # stuff data_type and behaviors in there for to_solr support
+            config[:predicate_mapping][vocab]["#{name}type".to_sym] = data_type if indexing
+            config[:predicate_mapping][vocab]["#{name}behaviors".to_sym] = behaviors if indexing
           else
             config = {
               :default_namespace => vocab,
               :predicate_mapping => {
-                vocab => { name => predicate, "#{name}type".to_sym => data_type }
+                vocab => { name => predicate }
               }
             }
+            # stuff data_type and behaviors in there for to_solr support
+            config[:predicate_mapping][vocab]["#{name}type".to_sym] = data_type if indexing
+            config[:predicate_mapping][vocab]["#{name}behaviors".to_sym] = behaviors if indexing
           end
         end
       end
     end
-
     class TermProxy
       # @param [Symbol, RDF::URI] predicate  the predicate to insert into the graph
       # @param [ActiveFedora::RelationshipGraph] graph  the graph
       # @param [Array] values  an array of object values
-      include Enumerable
+      instance_methods.each { |m| undef_method m unless m.to_s =~ /^(?:nil\?|send|object_id|to_a)$|^__|^respond_to|proxy_/ }
+      
       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 == @values
-      end
       def delete(*values)
         values.each do |value| 
           unless @values.delete(value).nil?
@@ -84,9 +109,25 @@ module ActiveFedora
         end
         @values
       end
-      def empty?
-        @values.empty?
+      def method_missing(method, *args)
+        unless @values.respond_to?(method)
+          message = "undefined method `#{method.to_s}' for \"#{@values}\":#{@values.class.to_s}"
+          raise NoMethodError, message
+        end
+
+        if block_given?
+          @values.send(method, *args)  { |*block_args| yield(*block_args) }
+        else
+          @values.send(method, *args)
+        end
+  
       end
+      # def empty?
+      #   @values.empty?
+      # end
+      # def to_s
+      #   @values.to_s
+      # end
     end
     
     include ModelMethods
@@ -107,29 +148,34 @@ module ActiveFedora
       end
     end
 
-    # returns a Hash, e.g.: {field => {:values => values, :type => type}, ...}
+    # returns a Hash, e.g.: {field => {:values => [], :type => :something, :behaviors => []}, ...}
     def fields
       field_map = {}
       graph.relationships.each do |predicate, values|
         vocab_sym, name = predicate.qname
         vocabs_list = self.class.vocabularies.select { |ns, v| v.__prefix__ == vocab_sym }
         vocab = vocabs_list.first.first.to_s
-        mapped_names = self.class.config[:predicate_mapping][vocab].select {|k, v| v.to_s == name.to_s}
+        vocab_hash = self.class.config[:predicate_mapping][vocab]
+        mapped_names = vocab_hash.select {|k, v| v.to_s == name.to_s}
         name = mapped_names.first.first.to_s
-        type = self.class.config[:predicate_mapping][vocab]["#{name}type".to_sym]
-        field_map[name.to_sym] = {:values => values.map {|v| v.to_s}, :type => type}
+        next unless vocab_hash.has_key?("#{name}type".to_sym) and vocab_hash.has_key?("#{name}behaviors".to_sym)
+        type = vocab_hash["#{name}type".to_sym]
+        behaviors = vocab_hash["#{name}behaviors".to_sym]
+        field_map[name.to_sym] = {:values => values.map {|v| v.to_s}, :type => type, :behaviors => behaviors}
       end
       field_map
     end
 
     def to_solr(solr_doc = Hash.new) # :nodoc:
       fields.each do |field_key, field_info|
-        if field_info.has_key?(:values) && !field_info[:values].nil?
-          field_symbol = ActiveFedora::SolrService.solr_name(field_key, field_info[:type])
-          values = field_info[:values]
-          values = [values] unless values.respond_to? :each
-          values.each do |val|    
-            ::Solrizer::Extractor.insert_solr_field_value(solr_doc, field_symbol, val)         
+        values = field_info.fetch(:values, false)
+        if values
+          field_info[:behaviors].each do |index_type|
+            field_symbol = ActiveFedora::SolrService.solr_name(field_key, field_info[:type], index_type)
+            values = [values] unless values.respond_to? :each
+            values.each do |val|    
+              ::Solrizer::Extractor.insert_solr_field_value(solr_doc, field_symbol, val)         
+            end
           end
         end
       end
@@ -140,7 +186,7 @@ module ActiveFedora
     def find_predicate(predicate)
       predicate = predicate.to_sym unless predicate.kind_of? RDF::URI
       result = ActiveFedora::Predicates.find_predicate(predicate)
-      RDF::URI(result.reverse.to_s)
+      RDF::URI(result.reverse.join)
     end
 
     def graph
@@ -166,8 +212,10 @@ module ActiveFedora
       ensure_loaded
       predicate = find_predicate(predicate) unless predicate.kind_of? RDF::URI
       graph.delete(predicate)
+
+      args = [args] unless args.respond_to? :each
       args.each do |arg|
-        graph.add(predicate, arg, true)
+        graph.add(predicate, arg, true) unless arg.empty?
       end
       graph.dirty = true
       return TermProxy.new(graph, predicate, args)

data/lib/active_fedora/solr_digital_object.rb

@@ -1,25 +1,37 @@
 module ActiveFedora
   class SolrDigitalObject
-    attr_reader :pid, :label, :state, :ownerId, :profile, :datastreams
+    attr_reader :pid, :label, :state, :ownerId, :profile, :datastreams, :solr_doc
     
-    def initialize(solr_doc)
+    def initialize(solr_doc, klass=ActiveFedora::Base)
+      @solr_doc = solr_doc
       @pid = solr_doc[SOLR_DOCUMENT_ID]
       profile_attrs = solr_doc.keys.select { |k| k =~ /^objProfile_/ }
       @profile = {}
       profile_attrs.each do |key|
         attr_name = key.split(/_/)[1..-2].join('_')
-        @profile[attr_name] = solr_doc[key].to_s
+        @profile[attr_name] = Array(solr_doc[key]).first.to_s
       end
       @profile['objCreateDate'] ||= Time.now.xmlschema
       @profile['objLastModDate'] ||= @profile['objCreateDate']
-      
+
       @datastreams = {}
+      
+      dsids = @solr_doc.keys.collect { |k| k.scan(/^(.+)_dsProfile_/).flatten.first }.compact.uniq
+      missing = dsids-klass.ds_specs.keys
+      missing.each do |dsid|
+        mime_key = ActiveFedora::SolrService.solr_name("#{dsid}_dsProfile_dsMIME",:symbol)
+        mime_type = Array(@solr_doc[mime_key]).first
+        ds_class = mime_type =~ /[\/\+]xml$/ ? NokogiriDatastream : Datastream
+        @datastreams[dsid] = ds_class.new(self, dsid)
+      end
+
       @label = @profile['objLabel']
       @state = @profile['objState']
       @ownerId = @profile['objOwnerId']
     end
-
+    
     def freeze
+      @finished = true
       @profile.freeze
       @datastreams.freeze
       self
@@ -29,5 +41,8 @@ module ActiveFedora
       false
     end
 
+    def repository
+      @finished ? ActiveFedora::Base.connection_for_pid(self.pid) : nil
+    end
   end
 end

data/lib/active_fedora/solr_service.rb

@@ -24,7 +24,6 @@ module ActiveFedora
       args = args.dup
       args.merge!(:url=>host)
       @conn = RSolr.connect args
- #     @conn = Solr::Connection.new(host, opts)
     end
     
     def self.instance

data/lib/active_fedora/version.rb

@@ -1,3 +1,3 @@
 module ActiveFedora
-    VERSION = "4.0.0.rc9"
+    VERSION = "4.0.0.rc10"
 end

data/spec/integration/base_spec.rb

@@ -217,10 +217,8 @@ describe ActiveFedora::Base do
     it "should expose the DC datastream" do
       dc = @test_object.dc
       dc.should be_a_kind_of(ActiveFedora::Datastream)
-      #dc["identifier"].should_not be_nil
       rexml = REXML::Document.new(dc.content)
       rexml.root.elements["dc:identifier"].get_text.should_not be_nil
-      #dc.elements["dc:identifier"].should_not be_nil
     end
   end
 
@@ -671,4 +669,13 @@ describe ActiveFedora::Base do
       
     end
   end
+
+  describe "#exists?" do
+    it "should return true for objects that exist" do
+      ActiveFedora::Base.exists?('hydrangea:fixture_mods_article1').should be_true
+    end
+    it "should return false for objects that dont exist" do
+      ActiveFedora::Base.exists?('nil:object').should be_false
+    end
+  end
 end

data/spec/integration/bug_spec.rb

@@ -51,10 +51,4 @@ describe 'bugs' do
     x.datastreams['someData'].fubar_values.should == ["meh"]
     x.save
   end
-  it "should update the index, even if there is no metadata" do
-    pending
-    oh = FooHistory.new
-    oh.save
-  end
-
 end

data/spec/integration/model_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'spec/samples/models/hydrangea_article'
+#require 'spec/samples/models/hydrangea_article'
 
 include ActiveFedora::Model
 include Mocha::API

data/spec/integration/solr_service_spec.rb

@@ -73,6 +73,11 @@ describe ActiveFedora::SolrService do
       end
     end
     
+    it 'should instantiate all datastreams in the solr doc, even ones undeclared by the class' do
+      obj = ActiveFedora::Base.load_instance_from_solr "hydrangea:fixture_mods_article1"
+      obj.datastreams.keys.should include('descMetadata')
+    end
+    
     it 'should #reify a lightweight object as a new instance' do
       query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
       solr_result = ActiveFedora::SolrService.query(query)

data/spec/samples/models/hydrangea_article.rb

@@ -1,6 +1,6 @@
 require "active-fedora"
-require 'spec/samples/hydra-mods_article_datastream.rb'
-require 'spec/samples/hydra-rights_metadata_datastream.rb'
+require 'samples/hydra-mods_article_datastream.rb'
+require 'samples/hydra-rights_metadata_datastream.rb'
 
 # This Model is used to load & index the hydrangea:fixture_mods_article1 fixture for use in tests.
 #

data/spec/samples/samples.rb

@@ -1,2 +1,2 @@
 # require all of the files in the samples directory
-require 'spec/samples/models/hydrangea_article'
+require 'samples/models/hydrangea_article'

data/spec/unit/base_file_management_spec.rb

@@ -61,7 +61,6 @@ describe ActiveFedora::Base do
       it "should be a supported method" do
         @base.should respond_to(:collection_members_remove)
       end
-      it "should remove hasCollectionMember for the given object/pid"
     end
   end
   

data/spec/unit/base_spec.rb

@@ -415,7 +415,10 @@ describe ActiveFedora::Base do
         @test_object.save
       end
       it "should NOT update solr index if no MetadataDatastreams have changed" do
-        pending "Rels-ext is getting automatically added so we can't test this."
+        stub_ingest(@this_pid)
+        stub_add_ds(@this_pid, ['ds1', 'RELS-EXT'])
+        @test_object.save
+        @test_object.expects(:new_object?).returns(false).twice
         ActiveFedora::DigitalObject.any_instance.stubs(:save)
         mock1 = mock("ds1")
         mock1.expects( :changed?).returns(false).at_least_once

data/spec/unit/datastreams_spec.rb

@@ -16,6 +16,10 @@ describe ActiveFedora::Datastreams do
       ds = @test_object.datastream_from_spec({:type=>ActiveFedora::Datastream, :versionable=>true}, 'test')
       ds.versionable.should be_true
     end
+    it "should default versionable to true" do
+      ds = @test_object.datastream_from_spec({:type=>ActiveFedora::Datastream}, 'test') 
+      ds.versionable.should be_true
+    end
 
   end
 
@@ -33,6 +37,39 @@ describe ActiveFedora::Datastreams do
       #ActiveFedora::RubydoraConnection.instance.stubs(:nextid).returns(@this_pid)
     end
 
+    describe "updates the spec" do
+      before do
+        class FooHistory < ActiveFedora::Base
+        end
+      end
+      after do
+        Object.send(:remove_const, :FooHistory)
+      end
+      subject { FooHistory}
+      it "should update the ds_spec" do
+        FooHistory.ds_specs.keys.should == ['RELS-EXT']
+        FooHistory.has_metadata :type=>ActiveFedora::Datastream, :name=>'new_ds'
+        FooHistory.ds_specs.keys.should include 'new_ds'
+      end
+      it "should be able to set a type" do
+        FooHistory.has_metadata :type=>ActiveFedora::Datastream, :name=>'new_ds', :control_group=>'R'
+        FooHistory.ds_specs['new_ds'][:control_group].should == 'R'
+      end
+      it "should be able to set versionable to false" do
+        FooHistory.has_metadata :type=>ActiveFedora::Datastream, :name=>'new_ds', :versionable=>false
+        FooHistory.ds_specs['new_ds'][:versionable].should be_false
+      end
+      it "should be able to set versionable to true" do
+        FooHistory.has_metadata :type=>ActiveFedora::Datastream, :name=>'new_ds', :versionable=>true
+        FooHistory.ds_specs['new_ds'][:versionable].should be_true
+      end
+      it "should not set versionable if it's not supplied" do
+        FooHistory.has_metadata :type=>ActiveFedora::Datastream, :name=>'new_ds'
+        FooHistory.ds_specs['new_ds'].keys.should_not include :versionable
+      end
+      
+    end
+
     describe "creates datastreams" do
       before do
         class FooHistory < ActiveFedora::Base
@@ -40,14 +77,9 @@ describe ActiveFedora::Datastreams do
             m.field "fubar", :string
             m.field "swank", :text
           end
-          has_metadata :type=>ActiveFedora::MetadataDatastream, :name=>"withText" do |m|
-            m.field "fubar", :text
-          end
           has_metadata :type=>ActiveFedora::MetadataDatastream, :name=>"withText2", :label=>"withLabel" do |m|
             m.field "fubar", :text
           end 
-          delegate :fubar, :to=>'withText'
-          delegate :swank, :to=>'someData'
         end
         stub_ingest(@this_pid)
         stub_add_ds(@this_pid, ['RELS-EXT', 'someData', 'withText', 'withText2'])
@@ -106,6 +138,7 @@ describe ActiveFedora::Datastreams do
       @n.datastreams["UKETD_DC"].dsLocation.should == "sub_url/objects/#{@this_pid}/methods/hull-sDef:uketdObject/getUKETDMetadata"
     end
 
+
     context ":control_group => 'E'" do
       before do
         stub_get(@this_pid)

data/spec/unit/metadata_datastream_spec.rb

@@ -82,14 +82,6 @@ describe ActiveFedora::MetadataDatastream do
       @test_ds.should be_dirty
     end
     
-    it "should support single-value arguments (as opposed to a hash of values with array indexes as keys)" do
-      # In other words, { "fubar"=>"dork" } should have the same effect as { "fubar"=>{"0"=>"dork"} }
-      pending "this should be working, but for some reason, the updates don't stick"
-      result = @test_ds.update_indexed_attributes( { "fubar"=>"dork" } )
-      result.should == {"fubar"=>{"0"=>"dork"}}
-      @test_ds.fubar_values.should == ["dork"]
-    end
-    
     it "should work for text fields" do 
       att= {"swank"=>{"-1"=>"mork", "1"=>"york"}}
       result = @test_ds.update_indexed_attributes(att)
@@ -113,12 +105,6 @@ describe ActiveFedora::MetadataDatastream do
       result.should == {"swank"=>{"2"=>"mork"}}
     end
     
-    it "should return accurate response when multiple values have been added in a single run" do
-      pending
-      att= {"swank"=>{"-1"=>"mork", "0"=>"york"}}
-      @test_ds.update_indexed_attributes(att).should == {"swank"=>{"0"=>"york", "1"=>"mork"}}
-    end
-    
     it "should deal gracefully with adding new values at explicitly declared indexes" do
       @test_ds.fubar_values = ["all", "for", "the"]
       att = {"fubar"=>{"3"=>'glory'}}
@@ -346,8 +332,6 @@ describe ActiveFedora::MetadataDatastream do
       solr_doc["empty_field_t"].should be_nil
     end
     
-    it "should allow multiple values for a single field"
-    
     it 'should append create keys in format field_name + _ + field_type' do
       @test_ds.stubs(:fields).returns(@sample_fields)
       

data/spec/unit/ntriples_datastream_spec.rb

@@ -34,8 +34,8 @@ describe ActiveFedora::NtriplesRDFDatastream do
       @subject.based_near.should == ["New York, NY, US"]
       @subject.related_url.should == ["http://google.com/"]
     end
-    it "should return fields that are TermProxies" do
-      @subject.created.should be_kind_of ActiveFedora::RDFDatastream::TermProxy
+    it "should return fields that are not TermProxies" do
+      @subject.created.should be_kind_of Array
     end
     it "should have method missing" do
       lambda{@subject.frank}.should raise_exception ActiveFedora::UnregisteredPredicateError
@@ -56,7 +56,7 @@ describe ActiveFedora::NtriplesRDFDatastream do
   end
 
   describe "a new instance" do
-    before do
+    before(:each) do
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
         register_vocabularies RDF::DC
         map_predicates do |map|
@@ -66,36 +66,59 @@ describe ActiveFedora::NtriplesRDFDatastream do
       @subject = MyDatastream.new(@inner_object, 'mixed_rdf')
       @subject.stubs(:pid => 'test:1')
     end
+    after(:each) do
+      Object.send(:remove_const, :MyDatastream)
+    end
     it "should save and reload" do
       @subject.publisher = ["St. Martin's Press"]
       @subject.save
     end
-  end
+    it "should support to_s method" do
+      @subject.publisher.to_s.should == [].to_s
+      @subject.publisher = "Bob"
+      @subject.publisher.to_s.should == ["Bob"].to_s
+      @subject.publisher << "Jim"
+      @subject.publisher.to_s.should == ["Bob", "Jim"].to_s
+    end
+ end
 
   describe "solr integration" do
     before(:all) do
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
         register_vocabularies RDF::DC, RDF::FOAF, RDF::RDFS
         map_predicates do |map|
-          map.created(:in => RDF::DC, :type => :date)
-          map.title(:in => RDF::DC, :type => :text)
-          map.publisher(:in => RDF::DC)
-          map.based_near(:in => RDF::FOAF, :type => :text)
-          map.related_url(:to => "seeAlso", :in => RDF::RDFS, :type => :string)
+          map.created(:in => RDF::DC) do |index| 
+            index.as :sortable, :displayable
+            index.type :date
+          end
+          map.title(:in => RDF::DC) do |index|
+            index.as :searchable, :displayable, :sortable
+            index.type :text 
+          end
+          map.publisher(:in => RDF::DC) do |index| 
+            index.as :facetable, :sortable, :searchable, :displayable
+          end
+          map.based_near(:in => RDF::FOAF) do |index|
+            index.as :displayable, :facetable, :searchable 
+            index.type :text
+          end
+          map.related_url(:to => "seeAlso", :in => RDF::RDFS) do |index|
+            index.defaults
+          end
+          map.rights(:in => RDF::DC)
         end
       end
       @subject = MyDatastream.new(@inner_object, 'solr_rdf')
       @subject.content = File.new('spec/fixtures/solr_rdf_descMetadata.nt').read
       @subject.stubs(:pid => 'test:1')
       @subject.stubs(:new? => false)
-      @sample_fields = {:publisher => {:values => ["publisher1"], :type => :string}, 
-        :based_near => {:values => ["coverage1", "coverage2"], :type => :text}, 
-        :created => {:values => "fake-date", :type => :date},
-        :title => {:values => "fake-title", :type => :text},
-        :related_url => {:values => "http://example.org/", :type => :string},
-        :empty_field => {:values => []}
+      @sample_fields = {:publisher => {:values => ["publisher1"], :type => :string, :behaviors => [:facetable, :sortable, :searchable, :displayable]}, 
+        :based_near => {:values => ["coverage1", "coverage2"], :type => :text, :behaviors => [:displayable, :facetable, :searchable]}, 
+        :created => {:values => "fake-date", :type => :date, :behaviors => [:sortable, :displayable]},
+        :title => {:values => "fake-title", :type => :text, :behaviors => [:searchable, :displayable, :sortable]},
+        :related_url => {:values => "http://example.org/", :type =>:string, :behaviors => [:searchable]},
+        :empty_field => {:values => [], :type => :string, :behaviors => [:searchable]}
       } 
-      @sample_xml = XmlSimple.xml_in("<fields><based_near>coverage1</based_near><based_near>coverage2</based_near><created>fake-date</created><publisher>publisher1</publisher><related_url>http://example.org/</related_url><title>fake-title</title></fields>")
     end
     after(:all) do
       # Revert to default mappings after running tests
@@ -117,9 +140,17 @@ describe ActiveFedora::NtriplesRDFDatastream do
       @subject.expects(:fields).returns(@sample_fields)
       solr_doc = @subject.to_solr
       solr_doc["publisher_t"].should == ["publisher1"]
+      solr_doc["publisher_sort"].should == ["publisher1"]
+      solr_doc["publisher_display"].should == ["publisher1"]
+      solr_doc["publisher_facet"].should == ["publisher1"]
       solr_doc["based_near_t"].sort.should == ["coverage1", "coverage2"]
-      solr_doc["created_dt"].should == ["fake-date"]
+      solr_doc["based_near_display"].sort.should == ["coverage1", "coverage2"]
+      solr_doc["based_near_facet"].sort.should == ["coverage1", "coverage2"]
+      solr_doc["created_sort"].should == ["fake-date"]
+      solr_doc["created_display"].should == ["fake-date"]
       solr_doc["title_t"].should == ["fake-title"]
+      solr_doc["title_sort"].should == ["fake-title"]
+      solr_doc["title_display"].should == ["fake-title"]
       solr_doc["related_url_t"].should == ["http://example.org/"]
       solr_doc["empty_field_t"].should be_nil
     end
@@ -130,9 +161,9 @@ describe ActiveFedora::NtriplesRDFDatastream do
       #should have these            
       @subject.to_solr["publisher_t"].should_not be_nil
       @subject.to_solr["based_near_t"].should_not be_nil
-      @subject.to_solr["created_dt"].should_not be_nil
       @subject.to_solr["title_t"].should_not be_nil
-      
+      @subject.to_solr["related_url_t"].should_not be_nil
+
       #should NOT have these
       @subject.to_solr["narrator"].should be_nil
       @subject.to_solr["empty_field"].should be_nil
@@ -142,11 +173,11 @@ describe ActiveFedora::NtriplesRDFDatastream do
       ActiveFedora::SolrService.load_mappings(File.join(File.dirname(__FILE__), "..", "..", "config", "solr_mappings_af_0.1.yml"))
       @subject.stubs(:fields).returns(@sample_fields)
       solr_doc =  @subject.to_solr
-      
+
       #should have these            
       solr_doc["publisher_field"].should == ["publisher1"]
       solr_doc["based_near_field"].sort.should == ["coverage1", "coverage2"]
-      solr_doc["created_date"].should == ["fake-date"]
+      solr_doc["created_display"].should == ["fake-date"]
       solr_doc["title_field"].should == ["fake-title"]
         
       solr_doc["title_t"].should be_nil
@@ -157,15 +188,6 @@ describe ActiveFedora::NtriplesRDFDatastream do
       # Reload default mappings
       ActiveFedora::SolrService.load_mappings
     end
-    it 'should append _dt to dates' do
-      ActiveFedora::SolrService.load_mappings
-      @subject.expects(:fields).returns(@sample_fields).at_least_once
-      @subject.to_solr["created_dt"].should_not be_nil
-      
-      #should NOT have these      
-      @subject.to_solr["created"].should be_nil
-      @subject.to_solr["created_date"].should be_nil
-    end
     describe "with an actual object" do
       before(:all) do
         @obj = MyDatastream.new(@inner_object, 'solr_rdf')
@@ -174,6 +196,7 @@ describe ActiveFedora::NtriplesRDFDatastream do
         @obj.publisher = "Bob's Blogtastic Publishing"
         @obj.based_near = ["Tacoma, WA", "Renton, WA"]
         @obj.related_url = "http://example.org/blogtastic/"
+        @obj.rights = "Totally open, y'all"
         @obj.save
       end
       describe ".fields()" do
@@ -201,14 +224,22 @@ describe ActiveFedora::NtriplesRDFDatastream do
       end
       describe ".to_solr()" do
         it "should return the right # of fields" do
-          @obj.to_solr.keys.count.should == 5
+          @obj.to_solr.keys.count.should == 13
         end
         it "should return the right fields" do
           @obj.to_solr.keys.should include("related_url_t")
           @obj.to_solr.keys.should include("publisher_t")
-          @obj.to_solr.keys.should include("created_dt")
+          @obj.to_solr.keys.should include("publisher_sort")
+          @obj.to_solr.keys.should include("publisher_display")
+          @obj.to_solr.keys.should include("publisher_facet")
+          @obj.to_solr.keys.should include("created_sort")
+          @obj.to_solr.keys.should include("created_display")
           @obj.to_solr.keys.should include("title_t")
+          @obj.to_solr.keys.should include("title_sort")
+          @obj.to_solr.keys.should include("title_display")
           @obj.to_solr.keys.should include("based_near_t")
+          @obj.to_solr.keys.should include("based_near_facet")
+          @obj.to_solr.keys.should include("based_near_display")
         end
         it "should return the right values" do
           @obj.to_solr["related_url_t"].should == ["http://example.org/blogtastic/"]

data/spec/unit/property_spec.rb

@@ -15,25 +15,10 @@ describe ActiveFedora::Property do
     ActiveFedora::Property.should respond_to(:new)
   end
 
-  describe '.new' do
-    
-    it 'should use assertions to check types of incoming args'
-    
-    # This could rely on property_set and in turn serialize to a 'properties' metadata datastream...
-    it 'should add corresponding field to the properties datastream'
-      
-    it 'should add field to repository indexer (ie. solr)'
-  end
-  
   it 'should provide .name' do
     ActiveFedora::Property.should respond_to(:name)
   end
 
-  describe '.name' do
-    it 'should return the value of the name attribute' do
-      
-    end
-  end
   
   it 'should provide .instance_variable_name' do
     #ActiveFedora::Property.should respond_to(:instance_variable_name)

data/spec/unit/service_definitions_spec.rb

@@ -48,7 +48,14 @@ describe ActiveFedora::ServiceDefinitions do
       obj.document_style_1({:format=>'xml'})
     end
     it "should call the appropriate rubydora rest api method with a block" do
-      pending "how to mock the passed block to rubydora"
+      Rubydora::Repository.any_instance.stubs(:dissemination).with({:pid=>'monkey:99',:sdef=>'test:12', :method=>'getDocumentStyle1'}).yields "ping!","pang!"
+      obj = Test.new()
+      obj.stubs(:pid).returns('monkey:99')
+      block_response = ""
+      obj.document_style_1 {|res,req|
+        block_response += 'pong!' if res == "ping!" and req == "pang!"
+      }
+      block_response.should == "pong!"
     end
   end
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: active-fedora
 version: !ruby/object:Gem::Version 
-  hash: 15424135
+  hash: 15424129
   prerelease: 6
   segments: 
   - 4
   - 0
   - 0
   - rc
-  - 9
-  version: 4.0.0.rc9
+  - 10
+  version: 4.0.0.rc10
 platform: ruby
 authors: 
 - Matt Zumwalt
@@ -19,7 +19,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-08 00:00:00 Z
+date: 2012-03-12 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   prerelease: false