mods 0.0.15 → 0.0.16

data/.gitignore

@@ -20,3 +20,4 @@ tmp
 *.tmproj
 tmtags
 .idea/*
+to_delete

data/README.rdoc

@@ -37,6 +37,7 @@ TODO: Write usage instructions here
 
 == Releases
 
+0.0.16 add role convenience methods (within name node)
 0.0.15 make namespace aware processing the default
 0.0.14 don't lose xml encoding in reader.normalize_mods under jruby
 0.0.13 really really fix removal of xsi:schemaLocation in jruby

data/lib/mods/nom_terminology.rb

@@ -131,12 +131,49 @@ module Mods
           n.displayForm :path => 'displayForm'
           n.affiliation :path => 'affiliation'
           n.description_el :path => 'description' # description is used by Nokogiri
-          n.role :path => 'role/roleTerm' do |r|
-            r.type_at :path => "@type", :accessor => lambda { |a| a.text }
-            Mods::AUTHORITY_ATTRIBS.each { |attr_name|
-              r.send attr_name, :path => "@#{attr_name}", :accessor => lambda { |a| a.text }
+          n.role :path => 'role' do |r| 
+            r.roleTerm :path => 'roleTerm' do |rt|
+              rt.type_at :path => "@type", :accessor => lambda { |a| a.text }
+              Mods::AUTHORITY_ATTRIBS.each { |attr_name|
+                rt.send attr_name, :path => "@#{attr_name}", :accessor => lambda { |a| a.text }
+              }
+            end
+            # convenience method
+            r.authority :path => '.', :accessor => lambda { |role_node| 
+              a = nil
+              role_node.roleTerm.each { |role_t| 
+                # role_t.authority will be [] if it is missing from an earlier roleTerm
+                if role_t.authority && (!a || a.size == 0)
+                  a = role_t.authority
+                end
+              }
+              a
+            }
+            # convenience method            
+            r.code :path => '.', :accessor => lambda { |role_node| 
+              c = nil
+              role_node.roleTerm.each { |role_t|  
+                if role_t.type_at == 'code' 
+                  c ||= role_t.text
+                end
+              }
+              c
+            }
+            # convenience method
+            r.value :path => '.', :accessor => lambda { |role_node| 
+              val = nil
+              role_node.roleTerm.each { |role_t|  
+                if role_t.type_at == 'text' 
+                  val ||= role_t.text
+                end
+              }
+              # FIXME:  this is broken if there are multiple role codes and some of them are not marcrelator
+              if !val && role_node.code && role_node.authority.first =~ /marcrelator/
+                val = MARC_RELATOR[role_node.code.first]
+              end
+              val
             }
-          end
+          end # role node
         end # t._plain_name
 
         t.personal_name :path => '/mods/name[@type="personal"]'
@@ -583,12 +620,49 @@ module Mods
           n.displayForm :path => 'm:displayForm'
           n.affiliation :path => 'm:affiliation'
           n.description_el :path => 'm:description' # description is used by Nokogiri
-          n.role :path => 'm:role/m:roleTerm' do |r|
-            r.type_at :path => "@type", :accessor => lambda { |a| a.text }
-            Mods::AUTHORITY_ATTRIBS.each { |attr_name|
-              r.send attr_name, :path => "@#{attr_name}", :accessor => lambda { |a| a.text }
+          n.role :path => 'm:role' do |r| 
+            r.roleTerm :path => 'm:roleTerm' do |rt|
+              rt.type_at :path => "@type", :accessor => lambda { |a| a.text }
+              Mods::AUTHORITY_ATTRIBS.each { |attr_name|
+                rt.send attr_name, :path => "@#{attr_name}", :accessor => lambda { |a| a.text }
+              }
+            end
+            # convenience method
+            r.authority :path => '.', :accessor => lambda { |role_node| 
+              a = nil
+              role_node.roleTerm.each { |role_t|
+                # role_t.authority will be [] if it is missing from an earlier roleTerm
+                if role_t.authority && (!a || a.size == 0)
+                  a = role_t.authority
+                end
+              }
+              a
+            }
+            # convenience method            
+            r.code :path => '.', :accessor => lambda { |role_node| 
+              c = nil
+              role_node.roleTerm.each { |role_t|  
+                if role_t.type_at == 'code'
+                  c ||= role_t.text
+                end
+              }
+              c
+            }
+            # convenience method
+            r.value :path => '.', :accessor => lambda { |role_node| 
+              val = nil
+              role_node.roleTerm.each { |role_t|  
+                if role_t.type_at == 'text'
+                  val ||= role_t.text
+                end
+              }
+              # FIXME:  this is broken if there are multiple role codes and some of them are not marcrelator
+              if !val && role_node.code && role_node.authority.first =~ /marcrelator/
+                val = MARC_RELATOR[role_node.code.first]
+              end
+              val
             }
-          end
+          end # role node
         end # t._plain_name
 
         t.personal_name :path => '/m:mods/m:name[@type="personal"]'
@@ -880,23 +954,27 @@ module Mods
           n.nonSort :path => 'm:nonSort'
           n.partNumber :path => 'm:partNumber'
           n.partName :path => 'm:partName'
+          # convenience method
           n.sort_title :path => '.', :accessor => lambda { |node| 
             if node.type_at != "alternative" || (node.type_at == "alternative" && 
                   mods_ng_xml.xpath('/m:mods/m:titleInfo', {'m' => Mods::MODS_NS}).size == 1)
               node.title.text + (!node.subTitle.text.empty? ? "#{@title_delimiter}#{node.subTitle.text}" : "" ) 
             end
           }
+          # convenience method
           n.full_title :path => '.', :accessor => lambda { |node| 
              (!node.nonSort.text.empty? ? "#{node.nonSort.text} " : "" ) + 
              node.title.text + 
              (!node.subTitle.text.empty? ? "#{@title_delimiter}#{node.subTitle.text}" : "" ) 
           }
+          # convenience method
           n.short_title :path => '.', :accessor => lambda { |node|  
             if node.type_at != "alternative"
               (!node.nonSort.text.empty? ? "#{node.nonSort.text} " : "" ) + 
               node.title.text
             end
           }
+          # convenience method
           n.alternative_title :path => '.', :accessor => lambda { |node|  
             if node.type_at == "alternative"
               (!node.nonSort.text.empty? ? "#{node.nonSort.text} " : "" ) + 

data/lib/mods/version.rb

@@ -1,4 +1,4 @@
 module Mods
   # this is the Ruby Gem version
-  VERSION = "0.0.15"
+  VERSION = "0.0.16"
 end

data/mods.gemspec

@@ -35,5 +35,5 @@ Gem::Specification.new do |gem|
 	gem.add_development_dependency 'simplecov'
 	gem.add_development_dependency 'simplecov-rcov'
 	# gem.add_development_dependency 'ruby-debug19'
-  
+  gem.add_development_dependency 'equivalent-xml'
 end

data/spec/name_spec.rb

@@ -7,38 +7,31 @@ describe "Mods <name> Element" do
     @ns_decl = "xmlns='#{Mods::MODS_NS}'"
     
     @corp_name = 'ABC corp'
-    @mods_w_corp_name = "<mods><name type='corporate'><namePart>#{@corp_name}</namePart></name></mods>"
     @mods_w_corp_name_ns = "<mods #{@ns_decl}><name type='corporate'><namePart>#{@corp_name}</namePart></name></mods>"
-    @mods_w_corp_name_role = "<mods><name type='corporate'><namePart>#{@corp_name}</namePart>
-      <role><roleTerm type='text'>lithographer</roleTerm></role></name></mods>"
+    @mods_w_corp_name = @mods_w_corp_name_ns.sub(" #{@ns_decl}", '')
     @mods_w_corp_name_role_ns = "<mods #{@ns_decl}><name type='corporate'><namePart>#{@corp_name}</namePart>
       <role><roleTerm type='text'>lithographer</roleTerm></role></name></mods>"
+    @mods_w_corp_name_role = @mods_w_corp_name_role_ns.sub(" #{@ns_decl}", '')
+
     @pers_name = 'Crusty'
-    @mods_w_pers_name = "<mods><name type='personal'><namePart>#{@pers_name}</namePart></name></mods>"
     @mods_w_pers_name_ns = "<mods #{@ns_decl}><name type='personal'><namePart>#{@pers_name}</namePart></name></mods>"
-    @mods_w_both = "<mods>
-      <name type='corporate'><namePart>#{@corp_name}</namePart></name>
-      <name type='personal'><namePart>#{@pers_name}</namePart></name></mods>"
+    @mods_w_pers_name = @mods_w_pers_name_ns.sub(" #{@ns_decl}", '')
     @mods_w_both_ns = "<mods #{@ns_decl}>
       <name type='corporate'><namePart>#{@corp_name}</namePart></name>
       <name type='personal'><namePart>#{@pers_name}</namePart></name></mods>"
+    @mods_w_both = @mods_w_both_ns.sub(" #{@ns_decl}", '')
+
     @pers_role = 'creator'
-    @mods_w_pers_name_role = "<mods><name type='personal'><namePart>#{@pers_name}</namePart>
-      <role><roleTerm authority='marcrelator' type='text'>#{@pers_role}</roleTerm><role></name></mods>"
     @mods_w_pers_name_role_ns = "<mods #{@ns_decl}><name type='personal'><namePart>#{@pers_name}</namePart>
       <role><roleTerm authority='marcrelator' type='text'>#{@pers_role}</roleTerm><role></name></mods>"
-    @mods_w_pers_name_role_code = "<mods><name type='personal'><namePart type='given'>John</namePart>
-        	<namePart type='family'>Huston</namePart>
-        	<role>
-        	  	<roleTerm type='code' authority='marcrelator'>drt</roleTerm>
-        	</role>
-      </name></mods>"
+    @mods_w_pers_name_role = @mods_w_pers_name_role_ns.sub(" #{@ns_decl}", '')
     @mods_w_pers_name_role_code_ns = "<mods #{@ns_decl}><name type='personal'><namePart type='given'>John</namePart>
         	<namePart type='family'>Huston</namePart>
         	<role>
         	  	<roleTerm type='code' authority='marcrelator'>drt</roleTerm>
         	</role>
       </name></mods>"
+    @mods_w_pers_name_role_code = @mods_w_pers_name_role_code_ns.sub(" #{@ns_decl}", '')
   end
   
   context "personal name" do
@@ -68,17 +61,17 @@ describe "Mods <name> Element" do
       context "roles" do
         it "should be possible to access a personal_name role easily" do
           @mods_rec.from_str(@mods_w_pers_name_role_ns)
-          @mods_rec.personal_name.role.text.should include(@pers_role)
+          @mods_rec.personal_name.role.roleTerm.text.should include(@pers_role)
         end
         it "should get role type" do
           @mods_rec.from_str(@mods_w_pers_name_role_ns)
-          @mods_rec.personal_name.role.type_at.should == ["text"]
+          @mods_rec.personal_name.role.roleTerm.type_at.should == ["text"]
           @mods_rec.from_str(@mods_w_pers_name_role_code_ns)
-          @mods_rec.personal_name.role.type_at.should == ["code"]
+          @mods_rec.personal_name.role.roleTerm.type_at.should == ["code"]
         end
         it "should get role authority" do
           @mods_rec.from_str(@mods_w_pers_name_role_ns)
-          @mods_rec.personal_name.role.authority.should == ["marcrelator"]
+          @mods_rec.personal_name.role.roleTerm.authority.should == ["marcrelator"]
         end
       end # roles
     end # WITH namespaces
@@ -112,13 +105,13 @@ describe "Mods <name> Element" do
         end
         it "should get role type" do
           @mods_rec.from_str(@mods_w_pers_name_role, false)
-          @mods_rec.personal_name.role.type_at.should == ["text"]
+          @mods_rec.personal_name.role.roleTerm.type_at.should == ["text"]
           @mods_rec.from_str(@mods_w_pers_name_role_code, false)
-          @mods_rec.personal_name.role.type_at.should == ["code"]
+          @mods_rec.personal_name.role.roleTerm.type_at.should == ["code"]
         end
         it "should get role authority" do
           @mods_rec.from_str(@mods_w_pers_name_role, false)
-          @mods_rec.personal_name.role.authority.should == ["marcrelator"]
+          @mods_rec.personal_name.role.roleTerm.authority.should == ["marcrelator"]
         end
       end # roles    
     end # WITHOUT namespaces
@@ -127,12 +120,6 @@ describe "Mods <name> Element" do
     
   end # personal name
   
-  context "sort_author" do
-    it "should do something" do
-      pending "sort_author to be implemented (choose creator if present ... )"
-    end
-  end
-  
   context "corporate name" do    
     context "WITH namespaces" do
       it "should recognize child elements" do
@@ -218,13 +205,13 @@ describe "Mods <name> Element" do
       context "role child element" do
         it "should get role type" do
           @mods_rec.from_str(@mods_w_pers_name_role_ns)
-          @mods_rec.plain_name.role.type_at.should == ["text"]
+          @mods_rec.plain_name.role.roleTerm.type_at.should == ["text"]
           @mods_rec.from_str(@mods_w_pers_name_role_code_ns)
-          @mods_rec.plain_name.role.type_at.should == ["code"]
+          @mods_rec.plain_name.role.roleTerm.type_at.should == ["code"]
         end
         it "should get role authority" do
           @mods_rec.from_str(@mods_w_pers_name_role_ns)
-          @mods_rec.plain_name.role.authority.should == ["marcrelator"]
+          @mods_rec.plain_name.role.roleTerm.authority.should == ["marcrelator"]
         end
       end
       
@@ -262,22 +249,250 @@ describe "Mods <name> Element" do
       context "role child element" do
         it "should get role type" do
           @mods_rec.from_str(@mods_w_pers_name_role, false)
-          @mods_rec.plain_name.role.type_at.should == ["text"]
+          @mods_rec.plain_name.role.roleTerm.type_at.should == ["text"]
           @mods_rec.from_str(@mods_w_pers_name_role_code, false)
-          @mods_rec.plain_name.role.type_at.should == ["code"]
+          @mods_rec.plain_name.role.roleTerm.type_at.should == ["code"]
         end
         it "should get role authority" do
           @mods_rec.from_str(@mods_w_pers_name_role, false)
-          @mods_rec.plain_name.role.authority.should == ["marcrelator"]
+          @mods_rec.plain_name.role.roleTerm.authority.should == ["marcrelator"]
         end
       end
     end # context WITHOUT namespaces
 
   end # plain name
-
   
   it "should be able to translate the marc relator code into text" do
     MARC_RELATOR['drt'].should == "Director"
   end
   
+  context "roles" do
+    before(:all) do
+      @xml_w_code = "<mods #{@ns_decl}><name><namePart>Alfred Hitchock</namePart>
+                <role><roleTerm type='code' authority='marcrelator'>drt</roleTerm></role>
+            </name></mods>"
+      @xml_w_text = "<mods #{@ns_decl}><name><namePart>Sean Connery</namePart>
+                <role><roleTerm type='text' authority='marcrelator'>Actor</roleTerm></role>
+            </name></mods>"
+      @xml_wo_authority = "<mods #{@ns_decl}><name><namePart>Exciting Prints</namePart>
+                <role><roleTerm type='text'>lithographer</roleTerm></role>
+            </name></mods>"
+      @xml_w_both = "<mods #{@ns_decl}><name><namePart>anyone</namePart>
+                <role>
+                  <roleTerm type='text' authority='marcrelator'>CreatorFake</roleTerm>
+                  <roleTerm type='code' authority='marcrelator'>cre</roleTerm>
+                </role>
+            </name></mods>"
+      @xml_w_mult_roles = "<mods #{@ns_decl}><name><namePart>Fats Waller</namePart>
+                <role><roleTerm type='text'>Creator</roleTerm>
+                      <roleTerm type='code' authority='marcrelator'>cre</roleTerm></role>
+                <role><roleTerm type='text'>Performer</roleTerm></role>
+            </name></mods>"
+    end
+
+    context "convenience methods WITH namespaces" do
+      before(:all) do
+        @mods_w_code = Mods::Record.new.from_str(@xml_w_code)
+        @mods_w_text = Mods::Record.new.from_str(@xml_w_text)
+        @mods_wo_authority = Mods::Record.new.from_str(@xml_wo_authority)
+        @mods_w_both = Mods::Record.new.from_str(@xml_w_both)
+        @mods_mult_roles = Mods::Record.new.from_str(@xml_w_mult_roles)
+      end  
+      context "value" do
+        it "should be the value of a text roleTerm" do
+          @mods_w_text.plain_name.role.value.should == ["Actor"]
+        end  
+        it "should be the translation of the code if it is a marcrelator code and there is no text roleTerm" do
+          @mods_w_code.plain_name.role.value.should == ["Director"]
+        end
+        it "should be the value of the text roleTerm if there are both a code and a text roleTerm" do
+          @mods_w_both.plain_name.role.value.should == ["CreatorFake"]
+        end
+        it "should have 2 values if there are 2 role elements" do
+          @mods_mult_roles.plain_name.role.value.should == ['Creator', 'Performer']
+        end
+      end
+      context "authority" do
+        it "should be empty if it is missing from xml" do
+          @mods_wo_authority.plain_name.role.authority.size.should == 0
+        end
+        it "should be the value of the authority attribute on the roleTerm element" do
+          @mods_w_code.plain_name.role.authority.should == ["marcrelator"]
+          @mods_w_text.plain_name.role.authority.should == ["marcrelator"]
+          @mods_w_both.plain_name.role.authority.should == ["marcrelator"]
+        end
+      end
+      context "code" do
+        it "should be empty if the roleTerm is not of type code" do
+          @mods_w_text.plain_name.role.code.size.should == 0
+          @mods_wo_authority.plain_name.role.code.size.should == 0
+        end
+        it "should be the value of the roleTerm element if element's type attribute is 'code'" do
+          @mods_w_code.plain_name.role.code.should == ["drt"]
+          @mods_w_both.plain_name.role.code.should == ["cre"]
+        end
+      end
+      context "pertaining to a specific name" do
+        before(:all) do
+          complex = "<mods #{@ns_decl}>
+                <name>
+                    <namePart>Sean Connery</namePart>
+                    <role><roleTerm type='code' authority='marcrelator'>drt</roleTerm></role>
+                </name>
+                <name>
+                    <namePart>Pierce Brosnan</namePart>
+                    <role>
+                      <roleTerm type='text'>CreatorFake</roleTerm>
+                      <roleTerm type='code' authority='marcrelator'>cre</roleTerm>
+                    </role>
+                    <role><roleTerm type='text' authority='marcrelator'>Actor</roleTerm></role>
+                </name>
+                <name>
+                    <namePart>Daniel Craig</namePart>
+                    <role>
+                      <roleTerm type='text' authority='marcrelator'>Actor</roleTerm>
+                      <roleTerm type='code' authority='marcrelator'>cre</roleTerm>
+                    </role>
+                </name>
+              </mods>"
+          @mods_complex = Mods::Record.new.from_str(complex)
+        end
+        it "roles should be empty array when there is no role element" do
+          @mods_rec.from_str(@mods_w_pers_name_ns)
+          @mods_rec.personal_name.first.role.size.should == 0
+        end
+        it "object should have same number of roles as it has role nodes in xml" do
+          @mods_complex.plain_name[0].role.size.should == 1
+          @mods_complex.plain_name[1].role.size.should == 2
+          @mods_complex.plain_name[2].role.size.should == 1
+        end
+        context "name's roles should be correctly populated" do
+          it "text attribute" do
+            @mods_complex.plain_name[0].role.value.should == ['Director']
+            @mods_complex.plain_name[1].role.value.should == ['CreatorFake', 'Actor']
+            @mods_complex.plain_name[2].role.value.should == ['Actor']
+          end
+          it "code attribute" do
+            @mods_complex.plain_name[0].role.code.should == ['drt']
+            @mods_complex.plain_name[1].role.code.should == ['cre']
+            @mods_complex.plain_name[2].role.code.should == ['cre']
+          end
+          it "authority attribute" do
+            @mods_complex.plain_name[0].role.authority.should == ['marcrelator']
+            @mods_complex.plain_name[1].role.authority.should == ['marcrelator', 'marcrelator']
+            @mods_complex.plain_name[2].role.authority.should == ['marcrelator']
+          end
+          it "multiple roles" do
+            @mods_mult_roles.plain_name.first.role.value.should == ['Creator', 'Performer']
+            @mods_mult_roles.plain_name.first.role.code.should == ['cre']
+            @mods_mult_roles.plain_name.role.first.roleTerm.authority.first.should == 'marcrelator'
+            @mods_mult_roles.plain_name.role.last.roleTerm.authority.size.should == 0
+          end      
+        end
+      end # pertaining to a specific name
+    end # roles WITH namespaces
+      
+    context "convenience methods WITHOUT namespaces" do
+      before(:all) do
+        @mods_w_code = Mods::Record.new.from_str(@xml_w_code.sub(" #{@ns_decl}", ''), false)
+        @mods_w_text = Mods::Record.new.from_str(@xml_w_text.sub(" #{@ns_decl}", ''), false)
+        @mods_wo_authority = Mods::Record.new.from_str(@xml_wo_authority.sub(" #{@ns_decl}", ''), false)
+        @mods_w_both = Mods::Record.new.from_str(@xml_w_both.sub(" #{@ns_decl}", ''), false)
+        @mods_mult_roles = Mods::Record.new.from_str(@xml_w_mult_roles.sub(" #{@ns_decl}", ''), false)
+      end
+      context "value" do
+        it "should be the value of a text roleTerm" do
+          @mods_w_text.plain_name.role.value.should == ["Actor"]
+        end  
+        it "should be the translation of the code if it is a marcrelator code and there is no text roleTerm" do
+          @mods_w_code.plain_name.role.value.should == ["Director"]
+        end
+        it "should be the value of the text roleTerm if there are both a code and a text roleTerm" do
+          @mods_w_both.plain_name.role.value.should == ["CreatorFake"]
+        end
+        it "should have 2 values if there are 2 role elements" do
+          @mods_mult_roles.plain_name.role.value.should == ['Creator', 'Performer']
+        end
+      end
+      context "authority" do
+        it "should be empty if it is missing from xml" do
+          @mods_wo_authority.plain_name.role.authority.size.should == 0
+        end
+        it "should be the value of the authority attribute on the roleTerm element" do
+          @mods_w_code.plain_name.role.authority.should == ["marcrelator"]
+          @mods_w_text.plain_name.role.authority.should == ["marcrelator"]
+          @mods_w_both.plain_name.role.authority.should == ["marcrelator"]
+        end
+      end
+      context "code" do
+        it "should be empty if the roleTerm is not of type code" do
+          @mods_w_text.plain_name.role.code.size.should == 0
+          @mods_wo_authority.plain_name.role.code.size.should == 0
+        end
+        it "should be the value of the roleTerm element if element's type attribute is 'code'" do
+          @mods_w_code.plain_name.role.code.should == ["drt"]
+          @mods_w_both.plain_name.role.code.should == ["cre"]
+        end
+      end
+      context "pertaining to a specific name" do
+        before(:all) do
+          complex = "<mods>
+                <name>
+                    <namePart>Sean Connery</namePart>
+                    <role><roleTerm type='code' authority='marcrelator'>drt</roleTerm></role>
+                </name>
+                <name>
+                    <namePart>Pierce Brosnan</namePart>
+                    <role>
+                      <roleTerm type='text'>CreatorFake</roleTerm>
+                      <roleTerm type='code' authority='marcrelator'>cre</roleTerm>
+                    </role>
+                    <role><roleTerm type='text' authority='marcrelator'>Actor</roleTerm></role>
+                </name>
+                <name>
+                    <namePart>Daniel Craig</namePart>
+                    <role>
+                      <roleTerm type='text' authority='marcrelator'>Actor</roleTerm>
+                      <roleTerm type='code' authority='marcrelator'>cre</roleTerm>
+                    </role>
+                </name>
+              </mods>"
+          @mods_complex = Mods::Record.new.from_str(complex, false)
+        end
+        it "roles should be empty array when there is no role element" do
+          @mods_rec.from_str(@mods_w_pers_name_ns)
+          @mods_rec.personal_name.first.role.size.should == 0
+        end
+        it "object should have same number of roles as it has role nodes in xml" do
+          @mods_complex.plain_name[0].role.size.should == 1
+          @mods_complex.plain_name[1].role.size.should == 2
+          @mods_complex.plain_name[2].role.size.should == 1
+        end
+        context "name's roles should be correctly populated" do
+          it "text attribute" do
+            @mods_complex.plain_name[0].role.value.should == ['Director']
+            @mods_complex.plain_name[1].role.value.should == ['CreatorFake', 'Actor']
+            @mods_complex.plain_name[2].role.value.should == ['Actor']
+          end
+          it "code attribute" do
+            @mods_complex.plain_name[0].role.code.should == ['drt']
+            @mods_complex.plain_name[1].role.code.should == ['cre']
+            @mods_complex.plain_name[2].role.code.should == ['cre']
+          end
+          it "authority attribute" do
+            @mods_complex.plain_name[0].role.authority.should == ['marcrelator']
+            @mods_complex.plain_name[1].role.authority.should == ['marcrelator', 'marcrelator']
+            @mods_complex.plain_name[2].role.authority.should == ['marcrelator']
+          end
+          it "multiple roles" do
+            @mods_mult_roles.plain_name.first.role.value.should == ['Creator', 'Performer']
+            @mods_mult_roles.plain_name.first.role.code.should == ['cre']
+            @mods_mult_roles.plain_name.role.first.roleTerm.authority.first.should == 'marcrelator'
+            @mods_mult_roles.plain_name.role.last.roleTerm.authority.size.should == 0
+          end      
+        end
+      end # pertaining to a specific name
+    end # WITHOUT namespaces        
+  end # roles
+  
 end

data/spec/subject_spec.rb

@@ -99,7 +99,7 @@ describe "Mods <subject> Element" do
       @pers_name_sub.personal_name.displayForm.map { |e| e.text }.should == ['Edward VI , king of England, 1537-1553']
     end
     it "should be able to identify roles associated with a name" do
-      @mult_corp_name_sub.corporate_name.role.map { |e| e.text }.should == ['lithographers.']
+      @mult_corp_name_sub.corporate_name.role.roleTerm.map { |e| e.text }.should == ['lithographers.']
     end
     it "should be able to identify dates associated with a name" do
       @mult_pers_name_sub.personal_name.date.map { |e| e.text }.should include("1818-1878")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mods
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.0.16
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-26 00:00:00.000000000 Z
+date: 2012-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -156,6 +156,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: equivalent-xml
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Parse MODS (Metadata Object Description Schema) records.  More information
   about MODS can be found at http://www.loc.gov/standards/mods/
 email:
@@ -214,7 +230,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3689606292418896094
+      hash: -1181909657495840648
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -223,7 +239,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3689606292418896094
+      hash: -1181909657495840648
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24