active-fedora 1.1.4.pre2 → 1.1.4

data/VERSION

@@ -1 +1 @@
-0.1.4.pre1
+1.1.4

data/active-fedora.gemspec

@@ -5,9 +5,9 @@
 
 Gem::Specification.new do |s|
   s.name = %q{active-fedora}
-  s.version = "1.1.4.pre2"
+  s.version = "1.1.4"
 
-  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Matt Zumwalt", "McClain Looney"]
   s.date = %q{2010-05-15}
   s.description = %q{ActiveFedora provides for creating and managing objects in the Fedora Repository Architecture.}
@@ -191,7 +191,9 @@ Gem::Specification.new do |s|
      "lib/active_fedora/datastream.rb",
      "lib/active_fedora/fedora_object.rb",
      "lib/active_fedora/metadata_datastream.rb",
+     "lib/active_fedora/metadata_datastream_helper.rb",
      "lib/active_fedora/model.rb",
+     "lib/active_fedora/nokogiri_datastream.rb",
      "lib/active_fedora/property.rb",
      "lib/active_fedora/qualified_dublin_core_datastream.rb",
      "lib/active_fedora/relationship.rb",
@@ -312,8 +314,6 @@ Gem::Specification.new do |s|
      "spec/unit/inheritance_spec.rb",
      "spec/unit/metadata_datastream_spec.rb",
      "spec/unit/model_spec.rb",
-     "spec/unit/mods_datastream_spec.rb",
-     "spec/unit/nokogiri_datastream_spec.rb",
      "spec/unit/property_spec.rb",
      "spec/unit/qualified_dublin_core_datastream_spec.rb",
      "spec/unit/relationship_spec.rb",

data/lib/active_fedora.rb

@@ -14,7 +14,9 @@ require 'active_fedora/base.rb'
 require 'active_fedora/content_model.rb'
 require 'active_fedora/datastream.rb'
 require 'active_fedora/fedora_object.rb'
+require 'active_fedora/metadata_datastream_helper.rb'
 require 'active_fedora/metadata_datastream.rb'
+require 'active_fedora/nokogiri_datastream'
 require 'active_fedora/model.rb'
 require 'active_fedora/property.rb'
 require 'active_fedora/qualified_dublin_core_datastream.rb'

data/lib/active_fedora/base.rb

@@ -371,24 +371,36 @@ module ActiveFedora
     end
     
     #Returns the xml version of this object as a string.
-    def to_xml(xml=REXML::Document.new("<xml><fields/><content/></xml>"))
-      fields_xml = xml.root.elements['fields']
-      {:id => pid, :system_create_date => self.create_date, :system_modified_date => self.modified_date, :active_fedora_model => self.class.inspect}.each_pair do |attribute_name, value|
-        el = REXML::Element.new(attribute_name.to_s)
-        el.text = value
-        fields_xml << el
+    def to_xml(xml=Nokogiri::XML::Document.parse("<xml><fields/><content/></xml>"))
+      fields_xml = xml.xpath('//fields').first
+      builder = Nokogiri::XML::Builder.with(fields_xml) do |fields_xml|
+        fields_xml.id_ pid
+        fields_xml.system_create_date self.create_date
+        fields_xml.system_modified_date self.modified_date
+        fields_xml.active_fedora_model self.class.inspect
       end
+      
+      # {:id => pid, :system_create_date => self.create_date, :system_modified_date => self.modified_date, :active_fedora_model => self.class.inspect}.each_pair do |attribute_name, value|
+      #   el = REXML::Element.new(attribute_name.to_s)
+      #   el.text = value
+      #   fields_xml << el
+      # end
       datastreams.each_value do |ds|        
-        ds.to_xml(fields_xml) if ds.kind_of?(ActiveFedora::MetadataDatastream) || ds.kind_of?(ActiveFedora::RelsExtDatastream)
+        ds.to_xml(fields_xml) if ds.included_modules.include?(ActiveFedora::MetadataDatastreamHelper) || ds.kind_of?(ActiveFedora::RelsExtDatastream)
       end
       return xml.to_s
     end
 
-    #Return a Solr::Document version of this object.
-    def to_solr(solr_doc = Solr::Document.new)
-      solr_doc << {SOLR_DOCUMENT_ID.to_sym => pid, solr_name(:system_create, :date) => self.create_date, solr_name(:system_modified, :date) => self.modified_date, solr_name(:active_fedora_model, :symbol) => self.class.inspect}
+    # Return a Solr::Document version of this object.
+    # @solr_doc (optional) Solr::Document to insert the fields into
+    # @opts (optional) Hash
+    # If opts[:model_only] == true, the base object metadata and the RELS-EXT datastream will be omitted.  This is mainly to support shelver, which calls .to_solr for each model an object subscribes to. 
+    def to_solr(solr_doc = Solr::Document.new, opts={})
+      unless opts[:model_only]
+        solr_doc << {SOLR_DOCUMENT_ID.to_sym => pid, solr_name(:system_create, :date) => self.create_date, solr_name(:system_modified, :date) => self.modified_date, solr_name(:active_fedora_model, :symbol) => self.class.inspect}
+      end
       datastreams.each_value do |ds|
-        solr_doc = ds.to_solr(solr_doc) if ds.kind_of?(ActiveFedora::MetadataDatastream) || ds.kind_of?(ActiveFedora::RelsExtDatastream)
+        solr_doc = ds.to_solr(solr_doc) if ds.kind_of?(ActiveFedora::MetadataDatastream) || ( ds.kind_of?(ActiveFedora::RelsExtDatastream) && !opts[:model_only] )
       end
       return solr_doc
     end

data/lib/active_fedora/metadata_datastream.rb

@@ -2,67 +2,51 @@ module ActiveFedora
   #this class represents a MetadataDatastream, a special case of ActiveFedora::Datastream
   class MetadataDatastream < Datastream
     
-    include ActiveFedora::SolrMapper
-    
-    attr_accessor :fields
+    include ActiveFedora::MetadataDatastreamHelper
 
-    #constructor, calls up to ActiveFedora::Datastream's constructor
-    def initialize(attrs=nil)
-      super
-      @fields={}
-    end
+    self.xml_model = ActiveFedora::MetadataDatastream
     
-    # sets the blob, which in this case is the xml version of self, then calls ActiveFedora::Datastream.save
-    def save
-      self.set_blob_for_save
-      super
-    end
-    
-    def set_blob_for_save # :nodoc:
-      self.blob = self.to_xml
-    end
-
-    def to_solr(solr_doc = Solr::Document.new) # :nodoc:
-      fields.each do |field_key, field_info|
-        if field_info.has_key?(:values) && !field_info[:values].nil?
-          field_symbol = generate_solr_symbol(field_key, field_info[:type])
-          field_info[:values].each do |val|             
-            solr_doc << Solr::Field.new(field_symbol => val)
-          end
-        end
-      end
-
-      return solr_doc
-    end
-    
-    def to_xml(xml = REXML::Document.new("<fields />")) #:nodoc:
-      fields.each_pair do |field,field_info|
-        el = REXML::Element.new("#{field.to_s}")
-          if field_info[:element_attrs]
-            field_info[:element_attrs].each{|k,v| el.add_attribute(k.to_s, v.to_s)}
-          end
-        field_info[:values].each do |val|
-          el = el.clone
-          el.text = val.to_s
-          if xml.class == REXML::Document
-            xml.root.elements.add(el)
-          else
-            xml.add(el)
-          end
-        end
-      end
-      return xml.to_s
-    end
-    
-    # @tmpl ActiveFedora::MetadataDatastream
-    # @node Nokogiri::XML::Node
-    def self.from_xml(tmpl, node) # :nodoc:
-      node.xpath("./foxml:datastreamVersion[last()]/foxml:xmlContent/fields/node()").each do |f|
-          tmpl.send("#{f.name}_append", f.text) unless f.class == Nokogiri::XML::Text
-      end
-      tmpl.send(:dirty=, false)
-      tmpl
-    end
+    # def to_solr(solr_doc = Solr::Document.new) # :nodoc:
+    #   fields.each do |field_key, field_info|
+    #     if field_info.has_key?(:values) && !field_info[:values].nil?
+    #       field_symbol = generate_solr_symbol(field_key, field_info[:type])
+    #       field_info[:values].each do |val|             
+    #         solr_doc << Solr::Field.new(field_symbol => val)
+    #       end
+    #     end
+    #   end
+    # 
+    #   return solr_doc
+    # end
+    # 
+    # def to_xml(xml = REXML::Document.new("<fields />")) #:nodoc:
+    #   fields.each_pair do |field,field_info|
+    #     el = REXML::Element.new("#{field.to_s}")
+    #       if field_info[:element_attrs]
+    #         field_info[:element_attrs].each{|k,v| el.add_attribute(k.to_s, v.to_s)}
+    #       end
+    #     field_info[:values].each do |val|
+    #       el = el.clone
+    #       el.text = val.to_s
+    #       if xml.class == REXML::Document
+    #         xml.root.elements.add(el)
+    #       else
+    #         xml.add(el)
+    #       end
+    #     end
+    #   end
+    #   return xml.to_s
+    # end
+    # 
+    # # @tmpl ActiveFedora::MetadataDatastream
+    # # @node Nokogiri::XML::Node
+    # def self.from_xml(tmpl, node) # :nodoc:
+    #   node.xpath("./foxml:datastreamVersion[last()]/foxml:xmlContent/fields/node()").each do |f|
+    #       tmpl.send("#{f.name}_append", f.text) unless f.class == Nokogiri::XML::Text
+    #   end
+    #   tmpl.send(:dirty=, false)
+    #   tmpl
+    # end
     
     # This method generates the various accessor and mutator methods on self for the datastream metadata attributes.
     # each field will have the 3 magic methods:
@@ -108,27 +92,6 @@ module ActiveFedora
       EOS
     end
 
-    #get the field list
-    def self.fields
-      @@classFields
-    end
-
-    protected
-
-    def generate_solr_symbol(field_name, field_type) # :nodoc:
-      solr_name(field_name, field_type)
-      # #if field_name.to_s[-field_type.to_s.length - 1 .. -1] == "_#{field_type.to_s}"
-      # #  return field_name.to_sym
-      # case field_type
-      # when :date
-      #   return "#{field_name.to_s}_dt".to_sym
-      # when :string
-      #   return "#{field_name.to_s}_t".to_sym
-      # else
-      #   return "#{field_name.to_s}_t".to_sym
-      # end
-    end
-
   end
 
 end

data/lib/active_fedora/metadata_datastream_helper.rb

@@ -0,0 +1,104 @@
+#this class represents a MetadataDatastream, a special case of ActiveFedora::Datastream
+module ActiveFedora::MetadataDatastreamHelper 
+  
+  attr_accessor :fields
+  
+  module ClassMethods
+    
+    attr_accessor :xml_model
+    
+    #get the Class's field list
+    def fields
+      @@classFields
+    end
+    
+    # @tmpl ActiveFedora::MetadataDatastream
+    # @node Nokogiri::XML::Node
+    def from_xml(tmpl, node) # :nodoc:
+      node.xpath("./foxml:datastreamVersion[last()]/foxml:xmlContent/fields/node()").each do |f|
+          tmpl.send("#{f.name}_append", f.text) unless f.class == Nokogiri::XML::Text
+      end
+      tmpl.send(:dirty=, false)
+      tmpl
+    end
+    
+  end
+  
+  def self.included(klass)
+    klass.extend(ClassMethods)
+    klass.send(:include, ActiveFedora::SolrMapper)
+  end
+  
+  #constructor, calls up to ActiveFedora::Datastream's constructor
+  def initialize(attrs=nil)
+    super
+    @fields={}
+  end
+  
+  # sets the blob, which in this case is the xml version of self, then calls ActiveFedora::Datastream.save
+  def save
+    self.set_blob_for_save
+    super
+  end
+  
+  def set_blob_for_save # :nodoc:
+    self.blob = self.to_xml
+  end
+
+  def to_solr(solr_doc = Solr::Document.new) # :nodoc:
+    fields.each do |field_key, field_info|
+      if field_info.has_key?(:values) && !field_info[:values].nil?
+        field_symbol = generate_solr_symbol(field_key, field_info[:type])
+        field_info[:values].each do |val|             
+          solr_doc << Solr::Field.new(field_symbol => val)
+        end
+      end
+    end
+
+    return solr_doc
+  end
+  
+  def to_xml(xml = Nokogiri::XML::Document.parse("<fields />")) #:nodoc:
+    if xml.instance_of?(Nokogiri::XML::Document)
+      xml_insertion_point = xml.root
+    else
+      xml_insertion_point = xml
+    end
+    
+    builder = Nokogiri::XML::Builder.with(xml_insertion_point) do |xml|
+      fields.each_pair do |field,field_info|
+        element_attrs = field_info[:element_attrs].nil? ? {} : field_info[:element_attrs]
+        field_info[:values].each do |val|
+          builder_arg = "xml.#{field}(val, element_attrs)"
+          puts builder_arg.inspect
+          eval(builder_arg)
+        end
+      end
+    end
+    
+    # fields.each_pair do |field,field_info|
+    #       el = REXML::Element.new("#{field.to_s}")
+    #         if field_info[:element_attrs]
+    #           field_info[:element_attrs].each{|k,v| el.add_attribute(k.to_s, v.to_s)}
+    #         end
+    #       field_info[:values].each do |val|
+    #         el = el.clone
+    #         el.text = val.to_s
+    #         if xml.class == REXML::Document
+    #           xml.root.elements.add(el)
+    #         else
+    #           xml.add(el)
+    #         end
+    #       end
+    #     end
+    return builder.to_xml
+  end
+  
+
+  protected
+
+  def generate_solr_symbol(field_name, field_type) # :nodoc:
+    solr_name(field_name, field_type)
+  end
+
+end

data/lib/active_fedora/nokogiri_datastream.rb

@@ -0,0 +1,60 @@
+require "nokogiri"
+#this class represents a MetadataDatastream, a special case of ActiveFedora::Datastream
+class ActiveFedora::NokogiriDatastream < ActiveFedora::Datastream
+  
+  include ActiveFedora::MetadataDatastreamHelper
+  
+  self.xml_model = Nokogiri::XML::Document
+  
+  attr_accessor :ng_xml
+  
+  #constructor, calls up to ActiveFedora::Datastream's constructor
+  def initialize(attrs=nil)
+    super
+    @fields={}
+    @ng_xml = self.class.xml_model.new()
+  end
+  
+  def to_solr(solr_doc = Solr::Document.new) # :nodoc:
+    fields.each do |field_key, field_info|
+      if field_info.has_key?(:values) && !field_info[:values].nil?
+        field_symbol = generate_solr_symbol(field_key, field_info[:type])
+        field_info[:values].each do |val|             
+          solr_doc << Solr::Field.new(field_symbol => val)
+        end
+      end
+    end
+
+    return solr_doc
+  end
+  
+  def to_xml(xml = REXML::Document.new("<fields />")) #:nodoc:
+    fields.each_pair do |field,field_info|
+      el = REXML::Element.new("#{field.to_s}")
+        if field_info[:element_attrs]
+          field_info[:element_attrs].each{|k,v| el.add_attribute(k.to_s, v.to_s)}
+        end
+      field_info[:values].each do |val|
+        el = el.clone
+        el.text = val.to_s
+        if xml.class == REXML::Document
+          xml.root.elements.add(el)
+        else
+          xml.add(el)
+        end
+      end
+    end
+    return xml.to_s
+  end
+  
+  # @tmpl ActiveFedora::MetadataDatastream
+  # @node Nokogiri::XML::Node
+  def self.from_xml(tmpl, node) # :nodoc:
+    node.xpath("./foxml:datastreamVersion[last()]/foxml:xmlContent/fields/node()").each do |f|
+        tmpl.send("#{f.name}_append", f.text) unless f.class == Nokogiri::XML::Text
+    end
+    tmpl.send(:dirty=, false)
+    tmpl
+  end
+
+end

data/spec/integration/semantic_node_spec.rb

@@ -10,12 +10,12 @@ describe ActiveFedora::SemanticNode do
       has_relationship "collection_members", :has_collection_member
     end
     @node = SpecNode.new
-    class SpecModel < ActiveFedora::Base
+    class SNSpecModel < ActiveFedora::Base
       has_relationship("parts", :is_part_of, :inbound => true)
       has_relationship("containers", :is_member_of)
     end
     
-    @test_object = SpecModel.new
+    @test_object = SNSpecModel.new
     @test_object.save
     
     @part1 = ActiveFedora::Base.new()
@@ -43,7 +43,7 @@ describe ActiveFedora::SemanticNode do
     @container2.delete
     @test_object.delete
     
-    Object.send(:remove_const, :SpecModel)
+    Object.send(:remove_const, :SNSpecModel)
 
   end
   

data/spec/unit/base_spec.rb

@@ -285,8 +285,8 @@ describe ActiveFedora::Base do
     it "should call .to_xml on all MetadataDatastreams and return the resulting document" do
       mock1 = mock("ds1", :to_xml)
       mock2 = mock("ds2", :to_xml)
-      mock1.expects(:kind_of?).with(ActiveFedora::MetadataDatastream).returns(true)
-      mock2.expects(:kind_of?).with(ActiveFedora::MetadataDatastream).returns(true)
+      mock1.expects(:included_modules).returns( [ActiveFedora::MetadataDatastreamHelper] )
+      mock2.expects(:included_modules).returns( [ActiveFedora::MetadataDatastreamHelper] )
 
       @test_object.expects(:datastreams).returns({:ds1 => mock1, :ds2 => mock2})
       @test_object.to_xml
@@ -318,6 +318,16 @@ describe ActiveFedora::Base do
       solr_doc[:id].should eql(@test_object.pid)
     end
 
+    it "should omit base metadata and RELS-EXT if :model_only==true" do
+      @test_object.add_relationship(:has_part, "foo")
+      # @test_object.expects(:modified_date).returns("mDate")
+      solr_doc = @test_object.to_solr(Solr::Document.new, :model_only => true)
+      solr_doc[:system_create_dt].should be_nil
+      solr_doc[:system_modified_dt].should be_nil
+      solr_doc[:id].should be_nil
+      solr_doc[:has_part_s].should be_nil
+    end
+    
     it "should add self.class as the :active_fedora_model" do
       solr_doc = @test_object.to_solr
       solr_doc[:active_fedora_model_s].should eql(@test_object.class.inspect)
@@ -361,6 +371,7 @@ describe ActiveFedora::Base do
       rels_ext.expects(:to_solr)
       @test_object.to_solr
     end
+    
   end
 
   describe ".update_index" do

data/spec/unit/metadata_datastream_spec.rb

@@ -54,33 +54,29 @@ describe ActiveFedora::MetadataDatastream do
     end
     it 'should output the fields hash as XML' do
       @test_ds.expects(:fields).returns(@sample_fields)
-      #sample_rexml = REXML::Document.new(sample_xml)
-      #returned_rexml = REXML::Document.new(@test_ds.to_dc_xml)
-      #returned_rexml.to_s.should == sample_rexml.to_s
       returned_xml = XmlSimple.xml_in(@test_ds.to_xml)
       returned_xml.should == @sample_xml
     end
     
-    it 'should accept an optional REXML Document as an argument and insert its fields into that' do
-      @test_ds.expects(:fields).returns(@sample_fields)
-      rexml = REXML::Document.new("<test_rexml/>")
-      rexml.root.elements.expects(:add).times(5)
-      result = @test_ds.to_xml(rexml)
+    it 'should accept an optional Nokogiri::XML Document as an argument and insert its fields into that (mocked test)' do
+      doc = Nokogiri::XML::Document.parse("<test_rexml/>")
+      Nokogiri::XML::Builder.expects(:with).with(doc.root).returns(doc.root)      
+      result = @test_ds.to_xml(doc)
     end
-    it 'should accept an optional REXML Document as an argument and insert its fields into that' do
+    
+    it 'should accept an optional Nokogiri::XML Document as an argument and insert its fields into that (functional test)' do
       @test_ds.expects(:fields).returns(@sample_fields)
-      rexml = REXML::Document.new("<test_rexml/>")
-      result = @test_ds.to_xml(rexml)
-      XmlSimple.xml_in(rexml.to_s).should == @sample_xml
+      doc = Nokogiri::XML::Document.parse("<test_rexml/>")
+      result = @test_ds.to_xml(doc)
+      XmlSimple.xml_in(doc.to_s).should == @sample_xml
       XmlSimple.xml_in(result).should == @sample_xml
     end
     
-    it 'should add to root of REXML::Documents, but add directly to the elements if a REXML::Element is passed in' do
-      @test_ds.expects(:fields).returns(@sample_fields).times(2)
-      doc = REXML::Document.new("<test_document/>")
-      el = REXML::Element.new("<test_element/>")
-      doc.root.elements.expects(:add).times(5)
-      el.expects(:add).times(5)
+    it 'should add to root of Nokogiri::XML::Documents, but add directly to the elements if a REXML::Element is passed in' do
+      doc = Nokogiri::XML::Document.parse("<test_document/>")
+      el = Nokogiri::XML::Node.new("test_element", Nokogiri::XML::Document.new)
+      Nokogiri::XML::Builder.expects(:with).with(doc.root).returns(doc.root)
+      Nokogiri::XML::Builder.expects(:with).with(el).returns(el)
       @test_ds.to_xml(doc)
       @test_ds.to_xml(el)
     end
@@ -131,7 +127,8 @@ describe ActiveFedora::MetadataDatastream do
       sds = SpecDatastream.new
       sds.mycomplicated_field_values='foo'
       sds.fields[:mycomplicated_field][:element_attrs].should == {:foo=>:bar, :baz=>:bat}
-      sds.to_xml.should == '<fields><mycomplicated_field baz=\'bat\' foo=\'bar\'>foo</mycomplicated_field></fields>'
+      expected_xml = '<fields><mycomplicated_field baz=\'bat\' foo=\'bar\'>foo</mycomplicated_field></fields>'
+      XmlSimple.xml_in(sds.to_xml).should == XmlSimple.xml_in(expected_xml)
     end
     
     it "should add getters and setters and appenders with field name" do

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: active-fedora
 version: !ruby/object:Gem::Version 
-  prerelease: true
+  prerelease: false
   segments: 
   - 1
   - 1
   - 4
-  - pre2
-  version: 1.1.4.pre2
+  version: 1.1.4
 platform: ruby
 authors: 
 - Matt Zumwalt
@@ -296,7 +295,9 @@ files:
 - lib/active_fedora/datastream.rb
 - lib/active_fedora/fedora_object.rb
 - lib/active_fedora/metadata_datastream.rb
+- lib/active_fedora/metadata_datastream_helper.rb
 - lib/active_fedora/model.rb
+- lib/active_fedora/nokogiri_datastream.rb
 - lib/active_fedora/property.rb
 - lib/active_fedora/qualified_dublin_core_datastream.rb
 - lib/active_fedora/relationship.rb
@@ -392,13 +393,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version 
       segments: 
-      - 1
-      - 3
-      - 1
-      version: 1.3.1
+      - 0
+      version: "0"
 requirements: []
 
 rubyforge_project: rubyfedora
@@ -442,8 +441,6 @@ test_files:
 - spec/unit/inheritance_spec.rb
 - spec/unit/metadata_datastream_spec.rb
 - spec/unit/model_spec.rb
-- spec/unit/mods_datastream_spec.rb
-- spec/unit/nokogiri_datastream_spec.rb
 - spec/unit/property_spec.rb
 - spec/unit/qualified_dublin_core_datastream_spec.rb
 - spec/unit/relationship_spec.rb

data/spec/unit/mods_datastream_spec.rb

@@ -1,289 +0,0 @@
-require File.join( File.dirname(__FILE__), "../spec_helper" )
-
-require 'active_fedora'
-require 'hydra'
-
-describe ModsDatastream do
-  
-  before(:all) do
-    @sample_fields = {:publisher => {:values => ["publisher1"], :type => :string}, 
-                      :coverage => {:values => ["coverage1", "coverage2"], :type => :text}, 
-                      :creation_date => {:values => "fake-date", :type => :date},
-                      :mydate => {:values => "fake-date", :type => :date},
-                      :empty_field => {:values => {}}
-                      } 
-    @sample_xml = XmlSimple.xml_in("<fields><coverage>coverage1</coverage><coverage>coverage2</coverage><creation_date>fake-date</creation_date><mydate>fake-date</mydate><publisher>publisher1</publisher></fields>")
-    
-  end
-  
-  before(:each) do
-    @test_ds = ModsDatastream.new
-  end
-  
-  after(:each) do
-  end
-  
-  describe '#new' do
-    it 'should provide #new' do
-      ModsDatastream.should respond_to(:new)
-      @test_ds.ng_xml.should be_instance_of(OpinionatedModsDocument)
-    end
-  end
-  
-
-  it 'should provide .fields' do
-    @test_ds.should respond_to(:fields)
-  end
-  
-  describe '.save' do
-    it "should provide .save" do
-      @test_ds.should respond_to(:save)
-    end
-    it "should persist the product of .to_xml in fedora" do
-      Fedora::Repository.instance.expects(:save)
-      @test_ds.expects(:to_xml).returns("fake xml")
-      @test_ds.expects(:blob=).with("fake xml")
-      @test_ds.save
-    end
-  end
-  
-  describe '.to_xml' do
-    it "should provide .to_xml" do
-      @test_ds.should respond_to(:to_xml)
-    end
-    it 'should output the fields hash as XML' do
-      @test_ds.expects(:fields).returns(@sample_fields)
-      #sample_rexml = REXML::Document.new(sample_xml)
-      #returned_rexml = REXML::Document.new(@test_ds.to_dc_xml)
-      #returned_rexml.to_s.should == sample_rexml.to_s
-      returned_xml = XmlSimple.xml_in(@test_ds.to_xml)
-      returned_xml.should == @sample_xml
-    end
-    
-    it 'should accept an optional REXML Document as an argument and insert its fields into that' do
-      @test_ds.expects(:fields).returns(@sample_fields)
-      rexml = REXML::Document.new("<test_rexml/>")
-      rexml.root.elements.expects(:add).times(5)
-      result = @test_ds.to_xml(rexml)
-    end
-    it 'should accept an optional REXML Document as an argument and insert its fields into that' do
-      @test_ds.expects(:fields).returns(@sample_fields)
-      rexml = REXML::Document.new("<test_rexml/>")
-      result = @test_ds.to_xml(rexml)
-      XmlSimple.xml_in(rexml.to_s).should == @sample_xml
-      XmlSimple.xml_in(result).should == @sample_xml
-    end
-    
-    it 'should add to root of REXML::Documents, but add directly to the elements if a REXML::Element is passed in' do
-      @test_ds.expects(:fields).returns(@sample_fields).times(2)
-      doc = REXML::Document.new("<test_document/>")
-      el = REXML::Element.new("<test_element/>")
-      doc.root.elements.expects(:add).times(5)
-      el.expects(:add).times(5)
-      @test_ds.to_xml(doc)
-      @test_ds.to_xml(el)
-    end
-    
-  end
-  
-  describe '.set_blob_for_save' do
-    it "should provide .set_blob_for_save" do
-      @test_ds.should respond_to(:set_blob_for_save)
-    end
-    
-    it "should set the blob to to_xml" do
-      @test_ds.expects(:blob=).with(@test_ds.to_xml)
-      @test_ds.set_blob_for_save
-    end
-  end
-  
-  describe '#field' do
-    
-    before(:each) do
-      class SpecDatastream < ActiveFedora::MetadataDatastream
-        def initialize
-        super
-        field :publisher, :string
-        field :coverage, :text
-        field :creation_date, :date
-        field :mydate, :date
-        field :mycomplicated_field, :string, :multiple=>false, :encoding=>'LCSH', :element_attrs=>{:foo=>:bar, :baz=>:bat}
-        end
-      end
-    end
-    
-    after(:each) do
-      Object.send(:remove_const, :SpecDatastream)
-    end
-    
-    it 'should add corresponding field to the @fields hash and set the field :type ' do
-      sds = SpecDatastream.new
-      sds.fields.should_not have_key(:bio)
-      sds.field :bio, :text
-      sds.fields.should have_key(:bio)
-      sds.fields[:bio].should have_key(:type)
-      sds.fields[:bio][:type].should == :text
-      sds.fields[:mycomplicated_field][:element_attrs].should == {:foo=>:bar, :baz=>:bat}
-    end
-    
-    # it "should insert custom element attrs into the xml stream" do
-    #   sds = SpecDatastream.new
-    #   sds.mycomplicated_field_values='foo'
-    #   sds.fields[:mycomplicated_field][:element_attrs].should == {:foo=>:bar, :baz=>:bat}
-    #   sds.to_xml.should == '<fields><mycomplicated_field baz=\'bat\' foo=\'bar\'>foo</mycomplicated_field></fields>'
-    # end
-    
-    it "should add getters and setters and appenders with field name" do
-      local_test_ds = SpecDatastream.new
-      local_test_ds.should respond_to(:publisher_values)
-      local_test_ds.should respond_to(:publisher_append)
-      local_test_ds.should respond_to(:publisher_values=)
-      local_test_ds.publisher_values.class.should == Array
-      local_test_ds.should respond_to(:coverage_values)
-      local_test_ds.should respond_to(:coverage_values=)
-      local_test_ds.should respond_to(:coverage_append)
-      local_test_ds.should respond_to(:creation_date_values)
-      local_test_ds.should respond_to(:creation_date_append)
-      local_test_ds.should respond_to(:creation_date_values=)
-      local_test_ds.should respond_to(:mydate_values)
-      local_test_ds.should respond_to(:mydate_append)
-      local_test_ds.should respond_to(:mydate_values=)
-    end
-    
-    it "should track field values at instance level, not at class level" do
-      local_test_ds1 = SpecDatastream.new
-      local_test_ds2 = SpecDatastream.new
-      local_test_ds1.publisher_values = ["publisher1", "publisher2"]
-      local_test_ds2.publisher_values = ["publisherA", "publisherB"]
-      
-      local_test_ds2.publisher_values.should == ["publisherA", "publisherB"]      
-      local_test_ds1.publisher_values.should == ["publisher1", "publisher2"]
-    end
-    
-    it "should allow you to add field values using <<" do
-      local_test_ds1 = SpecDatastream.new
-      local_test_ds1.publisher_values << "publisher1"
-      local_test_ds1.publisher_values.should == ["publisher1"] 
-    end
-    
-    it "should create setter that always turns non-arrays into arrays" do
-      local_test_ds = SpecDatastream.new
-      local_test_ds.publisher_values = "Foo"
-      local_test_ds.publisher_values.should == ["Foo"]
-    end
-    
-    it "should create setter that sets datastream.dirty? to true" do
-      local_test_ds = SpecDatastream.new
-      local_test_ds.should_not be_dirty
-      local_test_ds.publisher_values = "Foo"
-      local_test_ds.should be_dirty
-      
-      # Note: If you use << to append values, the datastream will not be marked as dirty!
-      #local_test_ds.dirty = false
-      
-      #local_test_ds.should_not be_dirty
-      #local_test_ds.publisher_values << "Foo"
-      #local_test_ds.should be_dirty      
-    end
-    
-    it "should add any extra opts to the field hash" do
-      local_test_ds = SpecDatastream.new
-      local_test_ds.field "myfield", :string, :foo => "foo", :bar => "bar"      
-      local_test_ds.fields[:myfield].should have_key(:foo)
-      local_test_ds.fields[:myfield][:foo].should == "foo"
-      local_test_ds.fields[:myfield].should have_key(:bar)
-      local_test_ds.fields[:myfield][:bar].should == "bar"      
-    end
-    
-  end
-  
-  describe ".to_solr" do
-    
-    after(:all) do
-      # Revert to default mappings after running tests
-      ActiveFedora::SolrService.load_mappings
-    end
-    
-    it "should provide .to_solr and return a SolrDocument" do
-      @test_ds.should respond_to(:to_solr)
-      @test_ds.to_solr.should be_kind_of(Solr::Document)
-    end
-    
-    it "should optionally allow you to provide the Solr::Document to add fields to and return that document when done" do
-      doc = Solr::Document.new
-      @test_ds.to_solr(doc).should equal(doc)
-    end
-    
-    it "should iterate through @fields hash" do
-      @test_ds.expects(:fields).returns(@sample_fields)
-      solr_doc =  @test_ds.to_solr
-      
-      solr_doc[:publisher_t].should == "publisher1"
-      solr_doc[:coverage_t].should == "coverage1"
-      solr_doc[:creation_date_dt].should == "fake-date"
-      solr_doc[:mydate_dt].should == "fake-date"
-      
-      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)
-      
-      #should have these
-            
-      @test_ds.to_solr[:publisher_t].should_not be_nil
-      @test_ds.to_solr[:coverage_t].should_not be_nil
-      @test_ds.to_solr[:creation_date_dt].should_not be_nil
-      
-      #should NOT have these
-      @test_ds.to_solr[:narrator].should be_nil
-      @test_ds.to_solr[:title].should be_nil
-      @test_ds.to_solr[:empty_field].should be_nil
-      
-    end
-    
-    it "should use Solr mappings to generate field names" do
-      ActiveFedora::SolrService.load_mappings(File.join(File.dirname(__FILE__), "..", "..", "config", "solr_mappings_af_0.1.yml"))
-      @test_ds.stubs(:fields).returns(@sample_fields)
-      solr_doc =  @test_ds.to_solr
-      
-      #should have these
-            
-      solr_doc[:publisher_field].should == "publisher1"
-      solr_doc[:coverage_field].should == "coverage1"
-      solr_doc[:creation_date_date].should == "fake-date"
-      solr_doc[:mydate_date].should == "fake-date"
-      
-      solr_doc[:publisher_t].should be_nil
-      solr_doc[:coverage_t].should be_nil
-      solr_doc[:creation_date_dt].should be_nil
-      
-      # Reload default mappings
-      ActiveFedora::SolrService.load_mappings
-    end
-    
-    it 'should append _dt to dates' do
-      @test_ds.expects(:fields).returns(@sample_fields).at_least_once
-      
-      #should have these
-      
-      @test_ds.to_solr[:creation_date_dt].should_not be_nil
-      @test_ds.to_solr[:mydate_dt].should_not be_nil
-      
-      #should NOT have these
-      
-      @test_ds.to_solr[:mydate].should be_nil
-      @test_ds.to_solr[:creation_date_date].should be_nil
-    end
-    
-  end
-  
-  describe '.fields' do
-    it "should return a Hash" do
-      @test_ds.fields.should be_instance_of(Hash)
-    end
-  end
-  
-end

data/spec/unit/nokogiri_datastream_spec.rb

@@ -1,301 +0,0 @@
-require File.join( File.dirname(__FILE__), "../spec_helper" )
-
-require 'active_fedora'
-require 'active_fedora/nokogiri_datastream'
-
-describe ActiveFedora::NokogiriDatastream do
-  
-  before(:all) do
-    @sample_fields = {:publisher => {:values => ["publisher1"], :type => :string}, 
-                      :coverage => {:values => ["coverage1", "coverage2"], :type => :text}, 
-                      :creation_date => {:values => "fake-date", :type => :date},
-                      :mydate => {:values => "fake-date", :type => :date},
-                      :empty_field => {:values => {}}
-                      } 
-    @sample_xml = XmlSimple.xml_in("<fields><coverage>coverage1</coverage><coverage>coverage2</coverage><creation_date>fake-date</creation_date><mydate>fake-date</mydate><publisher>publisher1</publisher></fields>")
-    
-  end
-  
-  before(:each) do
-    @test_ds = ActiveFedora::NokogiriDatastream.new
-  end
-  
-  after(:each) do
-  end
-  
-  describe '#new' do
-    it 'should provide #new' do
-      ActiveFedora::NokogiriDatastream.should respond_to(:new)
-      @test_ds.ng_xml.should be_instance_of(Nokogiri::XML::Document)
-    end
-  end
-  
-
-  it 'should provide .fields' do
-    @test_ds.should respond_to(:fields)
-  end
-  
-  describe '.save' do
-    it "should provide .save" do
-      @test_ds.should respond_to(:save)
-    end
-    it "should persist the product of .to_xml in fedora" do
-      Fedora::Repository.instance.expects(:save)
-      @test_ds.expects(:to_xml).returns("fake xml")
-      @test_ds.expects(:blob=).with("fake xml")
-      @test_ds.save
-    end
-  end
-  
-  describe '.to_xml' do
-    it "should provide .to_xml" do
-      @test_ds.should respond_to(:to_xml)
-    end
-    it 'should output the fields hash as XML' do
-      @test_ds.expects(:fields).returns(@sample_fields)
-      returned_xml = XmlSimple.xml_in(@test_ds.to_xml)
-      returned_xml.should == @sample_xml
-    end
-    
-    it 'should accept an optional REXML Document as an argument and insert its fields into that' do
-      @test_ds.expects(:fields).returns(@sample_fields)
-      rexml = REXML::Document.new("<test_rexml/>")
-      rexml.root.elements.expects(:add).times(5)
-      result = @test_ds.to_xml(rexml)
-    end
-    it 'should accept an optional REXML Document as an argument and insert its fields into that' do
-      @test_ds.expects(:fields).returns(@sample_fields)
-      rexml = REXML::Document.new("<test_rexml/>")
-      result = @test_ds.to_xml(rexml)
-      XmlSimple.xml_in(rexml.to_s).should == @sample_xml
-      XmlSimple.xml_in(result).should == @sample_xml
-    end
-    
-    it 'should add to root of REXML::Documents, but add directly to the elements if a REXML::Element is passed in' do
-      @test_ds.expects(:fields).returns(@sample_fields).times(2)
-      doc = REXML::Document.new("<test_document/>")
-      el = REXML::Element.new("<test_element/>")
-      doc.root.elements.expects(:add).times(5)
-      el.expects(:add).times(5)
-      @test_ds.to_xml(doc)
-      @test_ds.to_xml(el)
-    end
-    
-  end
-  
-  describe '.set_blob_for_save' do
-    it "should provide .set_blob_for_save" do
-      @test_ds.should respond_to(:set_blob_for_save)
-    end
-    
-    it "should set the blob to to_xml" do
-      @test_ds.expects(:blob=).with(@test_ds.to_xml)
-      @test_ds.set_blob_for_save
-    end
-  end
-  
-  describe '#field' do
-    
-    before(:each) do
-      class SpecDatastream < ActiveFedora::MetadataDatastream
-        def initialize
-        super
-        field :publisher, :string
-        field :coverage, :text
-        field :creation_date, :date
-        field :mydate, :date
-        field :mycomplicated_field, :string, :multiple=>false, :encoding=>'LCSH', :element_attrs=>{:foo=>:bar, :baz=>:bat}
-        end
-      end
-    end
-    
-    after(:each) do
-      Object.send(:remove_const, :SpecDatastream)
-    end
-    
-    
-    decribe ".values" 
-      it "should call ng_xml.values_for(#{field_name}) OR call corresponding lookup method and build an array of values by calling .value on each node in the set"
-    end
-
-    decribe ".values<<" 
-      it "should call corresponding builder method"
-    end
-  
-    decribe ".values=" 
-      it "should wipe out any existing nodes, use the corresponding builder, and insert new node(s) as the replacement"
-    end
-    
-    it 'should add corresponding field to the @fields hash and set the field :type ' do
-      sds = SpecDatastream.new
-      sds.fields.should_not have_key(:bio)
-      sds.field :bio, :text
-      sds.fields.should have_key(:bio)
-      sds.fields[:bio].should have_key(:type)
-      sds.fields[:bio][:type].should == :text
-      sds.fields[:mycomplicated_field][:element_attrs].should == {:foo=>:bar, :baz=>:bat}
-    end
-    
-    # it "should insert custom element attrs into the xml stream" do
-    #   sds = SpecDatastream.new
-    #   sds.mycomplicated_field_values='foo'
-    #   sds.fields[:mycomplicated_field][:element_attrs].should == {:foo=>:bar, :baz=>:bat}
-    #   sds.to_xml.should == '<fields><mycomplicated_field baz=\'bat\' foo=\'bar\'>foo</mycomplicated_field></fields>'
-    # end
-    
-    it "should add getters and setters and appenders with field name" do
-      local_test_ds = SpecDatastream.new
-      local_test_ds.should respond_to(:publisher_values)
-      local_test_ds.should respond_to(:publisher_append)
-      local_test_ds.should respond_to(:publisher_values=)
-      local_test_ds.publisher_values.class.should == Array
-      local_test_ds.should respond_to(:coverage_values)
-      local_test_ds.should respond_to(:coverage_values=)
-      local_test_ds.should respond_to(:coverage_append)
-      local_test_ds.should respond_to(:creation_date_values)
-      local_test_ds.should respond_to(:creation_date_append)
-      local_test_ds.should respond_to(:creation_date_values=)
-      local_test_ds.should respond_to(:mydate_values)
-      local_test_ds.should respond_to(:mydate_append)
-      local_test_ds.should respond_to(:mydate_values=)
-    end
-    
-    it "should track field values at instance level, not at class level" do
-      local_test_ds1 = SpecDatastream.new
-      local_test_ds2 = SpecDatastream.new
-      local_test_ds1.publisher_values = ["publisher1", "publisher2"]
-      local_test_ds2.publisher_values = ["publisherA", "publisherB"]
-      
-      local_test_ds2.publisher_values.should == ["publisherA", "publisherB"]      
-      local_test_ds1.publisher_values.should == ["publisher1", "publisher2"]
-    end
-    
-    it "should allow you to add field values using <<" do
-      local_test_ds1 = SpecDatastream.new
-      local_test_ds1.publisher_values << "publisher1"
-      local_test_ds1.publisher_values.should == ["publisher1"] 
-    end
-    
-    it "should create setter that always turns non-arrays into arrays" do
-      local_test_ds = SpecDatastream.new
-      local_test_ds.publisher_values = "Foo"
-      local_test_ds.publisher_values.should == ["Foo"]
-    end
-    
-    it "should create setter that sets datastream.dirty? to true" do
-      local_test_ds = SpecDatastream.new
-      local_test_ds.should_not be_dirty
-      local_test_ds.publisher_values = "Foo"
-      local_test_ds.should be_dirty
-      
-      # Note: If you use << to append values, the datastream will not be marked as dirty!
-      #local_test_ds.dirty = false
-      
-      #local_test_ds.should_not be_dirty
-      #local_test_ds.publisher_values << "Foo"
-      #local_test_ds.should be_dirty      
-    end
-    
-    it "should add any extra opts to the field hash" do
-      local_test_ds = SpecDatastream.new
-      local_test_ds.field "myfield", :string, :foo => "foo", :bar => "bar"      
-      local_test_ds.fields[:myfield].should have_key(:foo)
-      local_test_ds.fields[:myfield][:foo].should == "foo"
-      local_test_ds.fields[:myfield].should have_key(:bar)
-      local_test_ds.fields[:myfield][:bar].should == "bar"      
-    end
-    
-  end
-  
-  describe ".to_solr" do
-    
-    after(:all) do
-      # Revert to default mappings after running tests
-      ActiveFedora::SolrService.load_mappings
-    end
-    
-    it "should iterate through the class fields, calling .values on each and appending the values to the solr doc"
-    
-    it "should provide .to_solr and return a SolrDocument" do
-      @test_ds.should respond_to(:to_solr)
-      @test_ds.to_solr.should be_kind_of(Solr::Document)
-    end
-    
-    it "should optionally allow you to provide the Solr::Document to add fields to and return that document when done" do
-      doc = Solr::Document.new
-      @test_ds.to_solr(doc).should equal(doc)
-    end
-    
-    it "should iterate through @fields hash" do
-      @test_ds.expects(:fields).returns(@sample_fields)
-      solr_doc =  @test_ds.to_solr
-      
-      solr_doc[:publisher_t].should == "publisher1"
-      solr_doc[:coverage_t].should == "coverage1"
-      solr_doc[:creation_date_dt].should == "fake-date"
-      solr_doc[:mydate_dt].should == "fake-date"
-      
-      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)
-      
-      #should have these
-            
-      @test_ds.to_solr[:publisher_t].should_not be_nil
-      @test_ds.to_solr[:coverage_t].should_not be_nil
-      @test_ds.to_solr[:creation_date_dt].should_not be_nil
-      
-      #should NOT have these
-      @test_ds.to_solr[:narrator].should be_nil
-      @test_ds.to_solr[:title].should be_nil
-      @test_ds.to_solr[:empty_field].should be_nil
-      
-    end
-    
-    it "should use Solr mappings to generate field names" do
-      ActiveFedora::SolrService.load_mappings(File.join(File.dirname(__FILE__), "..", "..", "config", "solr_mappings_af_0.1.yml"))
-      @test_ds.stubs(:fields).returns(@sample_fields)
-      solr_doc =  @test_ds.to_solr
-      
-      #should have these
-            
-      solr_doc[:publisher_field].should == "publisher1"
-      solr_doc[:coverage_field].should == "coverage1"
-      solr_doc[:creation_date_date].should == "fake-date"
-      solr_doc[:mydate_date].should == "fake-date"
-      
-      solr_doc[:publisher_t].should be_nil
-      solr_doc[:coverage_t].should be_nil
-      solr_doc[:creation_date_dt].should be_nil
-      
-      # Reload default mappings
-      ActiveFedora::SolrService.load_mappings
-    end
-    
-    it 'should append _dt to dates' do
-      @test_ds.expects(:fields).returns(@sample_fields).at_least_once
-      
-      #should have these
-      
-      @test_ds.to_solr[:creation_date_dt].should_not be_nil
-      @test_ds.to_solr[:mydate_dt].should_not be_nil
-      
-      #should NOT have these
-      
-      @test_ds.to_solr[:mydate].should be_nil
-      @test_ds.to_solr[:creation_date_date].should be_nil
-    end
-    
-  end
-  
-  describe '.fields' do
-    it "should return a Hash" do
-      @test_ds.fields.should be_instance_of(Hash)
-    end
-  end
-  
-end